qeth_l3_main.c 86.2 KB
Newer Older
1
/*
2
 *    Copyright IBM Corp. 2007, 2009
3 4 5 6 7 8
 *    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>
 */

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

12 13
#include <linux/module.h>
#include <linux/moduleparam.h>
J
Jiri Pirko 已提交
14
#include <linux/bitops.h>
15 16 17 18 19
#include <linux/string.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/etherdevice.h>
#include <linux/ip.h>
F
Frank Blaschka 已提交
20
#include <linux/ipv6.h>
21 22
#include <linux/inetdevice.h>
#include <linux/igmp.h>
23
#include <linux/slab.h>
J
Jiri Pirko 已提交
24
#include <linux/if_vlan.h>
25 26 27

#include <net/ip.h>
#include <net/arp.h>
28 29
#include <net/route.h>
#include <net/ip6_fib.h>
F
Frank Blaschka 已提交
30
#include <net/ip6_checksum.h>
31
#include <net/iucv/af_iucv.h>
32
#include <linux/hashtable.h>
33 34 35

#include "qeth_l3.h"

36

37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53
static int qeth_l3_set_offline(struct ccwgroup_device *);
static int qeth_l3_stop(struct net_device *);
static void qeth_l3_set_multicast_list(struct net_device *);
static int qeth_l3_register_addr_entry(struct qeth_card *,
		struct qeth_ipaddr *);
static int qeth_l3_deregister_addr_entry(struct qeth_card *,
		struct qeth_ipaddr *);

static int qeth_l3_isxdigit(char *buf)
{
	while (*buf) {
		if (!isxdigit(*buf++))
			return 0;
	}
	return 1;
}

54
static void qeth_l3_ipaddr4_to_string(const __u8 *addr, char *buf)
55
{
56
	sprintf(buf, "%pI4", addr);
57 58
}

59
static int qeth_l3_string_to_ipaddr4(const char *buf, __u8 *addr)
60 61
{
	int count = 0, rc = 0;
62
	unsigned int in[4];
63 64 65 66 67 68 69 70 71 72 73 74 75 76
	char c;

	rc = sscanf(buf, "%u.%u.%u.%u%c",
		    &in[0], &in[1], &in[2], &in[3], &c);
	if (rc != 4 && (rc != 5 || c != '\n'))
		return -EINVAL;
	for (count = 0; count < 4; count++) {
		if (in[count] > 255)
			return -EINVAL;
		addr[count] = in[count];
	}
	return 0;
}

77
static void qeth_l3_ipaddr6_to_string(const __u8 *addr, char *buf)
78
{
J
Joe Perches 已提交
79
	sprintf(buf, "%pI6", addr);
80 81
}

82
static int qeth_l3_string_to_ipaddr6(const char *buf, __u8 *addr)
83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165
{
	const char *end, *end_tmp, *start;
	__u16 *in;
	char num[5];
	int num2, cnt, out, found, save_cnt;
	unsigned short in_tmp[8] = {0, };

	cnt = out = found = save_cnt = num2 = 0;
	end = start = buf;
	in = (__u16 *) addr;
	memset(in, 0, 16);
	while (*end) {
		end = strchr(start, ':');
		if (end == NULL) {
			end = buf + strlen(buf);
			end_tmp = strchr(start, '\n');
			if (end_tmp != NULL)
				end = end_tmp;
			out = 1;
		}
		if ((end - start)) {
			memset(num, 0, 5);
			if ((end - start) > 4)
				return -EINVAL;
			memcpy(num, start, end - start);
			if (!qeth_l3_isxdigit(num))
				return -EINVAL;
			sscanf(start, "%x", &num2);
			if (found)
				in_tmp[save_cnt++] = num2;
			else
				in[cnt++] = num2;
			if (out)
				break;
		} else {
			if (found)
				return -EINVAL;
			found = 1;
		}
		start = ++end;
	}
	if (cnt + save_cnt > 8)
		return -EINVAL;
	cnt = 7;
	while (save_cnt)
		in[cnt--] = in_tmp[--save_cnt];
	return 0;
}

void qeth_l3_ipaddr_to_string(enum qeth_prot_versions proto, const __u8 *addr,
				char *buf)
{
	if (proto == QETH_PROT_IPV4)
		qeth_l3_ipaddr4_to_string(addr, buf);
	else if (proto == QETH_PROT_IPV6)
		qeth_l3_ipaddr6_to_string(addr, buf);
}

int qeth_l3_string_to_ipaddr(const char *buf, enum qeth_prot_versions proto,
				__u8 *addr)
{
	if (proto == QETH_PROT_IPV4)
		return qeth_l3_string_to_ipaddr4(buf, addr);
	else if (proto == QETH_PROT_IPV6)
		return qeth_l3_string_to_ipaddr6(buf, addr);
	else
		return -EINVAL;
}

static void qeth_l3_convert_addr_to_bits(u8 *addr, u8 *bits, int len)
{
	int i, j;
	u8 octet;

	for (i = 0; i < len; ++i) {
		octet = addr[i];
		for (j = 7; j >= 0; --j) {
			bits[i*8 + j] = octet & 1;
			octet >>= 1;
		}
	}
}

166
int qeth_l3_is_addr_covered_by_ipato(struct qeth_card *card,
167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202
						struct qeth_ipaddr *addr)
{
	struct qeth_ipato_entry *ipatoe;
	u8 addr_bits[128] = {0, };
	u8 ipatoe_bits[128] = {0, };
	int rc = 0;

	if (!card->ipato.enabled)
		return 0;

	qeth_l3_convert_addr_to_bits((u8 *) &addr->u, addr_bits,
				  (addr->proto == QETH_PROT_IPV4)? 4:16);
	list_for_each_entry(ipatoe, &card->ipato.entries, entry) {
		if (addr->proto != ipatoe->proto)
			continue;
		qeth_l3_convert_addr_to_bits(ipatoe->addr, ipatoe_bits,
					  (ipatoe->proto == QETH_PROT_IPV4) ?
					  4 : 16);
		if (addr->proto == QETH_PROT_IPV4)
			rc = !memcmp(addr_bits, ipatoe_bits,
				     min(32, ipatoe->mask_bits));
		else
			rc = !memcmp(addr_bits, ipatoe_bits,
				     min(128, ipatoe->mask_bits));
		if (rc)
			break;
	}
	/* invert? */
	if ((addr->proto == QETH_PROT_IPV4) && card->ipato.invert4)
		rc = !rc;
	else if ((addr->proto == QETH_PROT_IPV6) && card->ipato.invert6)
		rc = !rc;

	return rc;
}

203 204
inline int
qeth_l3_ipaddrs_is_equal(struct qeth_ipaddr *addr1, struct qeth_ipaddr *addr2)
205
{
206 207 208 209
	return addr1->proto == addr2->proto &&
		!memcmp(&addr1->u, &addr2->u, sizeof(addr1->u))  &&
		!memcmp(&addr1->mac, &addr2->mac, sizeof(addr1->mac));
}
210

211 212 213 214 215 216 217 218 219 220
static struct qeth_ipaddr *
qeth_l3_ip_from_hash(struct qeth_card *card, struct qeth_ipaddr *tmp_addr)
{
	struct qeth_ipaddr *addr;

	if (tmp_addr->is_multicast) {
		hash_for_each_possible(card->ip_mc_htable,  addr,
				hnode, qeth_l3_ipaddr_hash(tmp_addr))
			if (qeth_l3_ipaddrs_is_equal(tmp_addr, addr))
				return addr;
221
	} else {
222 223 224 225
		hash_for_each_possible(card->ip_htable,  addr,
				hnode, qeth_l3_ipaddr_hash(tmp_addr))
			if (qeth_l3_ipaddrs_is_equal(tmp_addr, addr))
				return addr;
226
	}
227 228

	return NULL;
229 230
}

231
int qeth_l3_delete_ip(struct qeth_card *card, struct qeth_ipaddr *tmp_addr)
232 233
{
	int rc = 0;
234
	struct qeth_ipaddr *addr;
235

236
	QETH_CARD_TEXT(card, 4, "delip");
237

238 239
	if (tmp_addr->proto == QETH_PROT_IPV4)
		QETH_CARD_HEX(card, 4, &tmp_addr->u.a4.addr, 4);
240
	else {
241 242
		QETH_CARD_HEX(card, 4, &tmp_addr->u.a6.addr, 8);
		QETH_CARD_HEX(card, 4, ((char *)&tmp_addr->u.a6.addr) + 8, 8);
243
	}
244 245 246 247 248 249 250 251 252 253 254

	addr = qeth_l3_ip_from_hash(card, tmp_addr);
	if (!addr)
		return -ENOENT;

	addr->ref_counter--;
	if (addr->type == QETH_IP_TYPE_NORMAL && addr->ref_counter > 0)
		return rc;
	if (addr->in_progress)
		return -EINPROGRESS;

255 256 257 258 259
	if (!qeth_card_hw_is_reachable(card)) {
		addr->disp_flag = QETH_DISP_ADDR_DELETE;
		return 0;
	}

260 261 262 263 264
	rc = qeth_l3_deregister_addr_entry(card, addr);

	hash_del(&addr->hnode);
	kfree(addr);

265 266 267
	return rc;
}

268
int qeth_l3_add_ip(struct qeth_card *card, struct qeth_ipaddr *tmp_addr)
269 270
{
	int rc = 0;
271
	struct qeth_ipaddr *addr;
272

273
	QETH_CARD_TEXT(card, 4, "addip");
274 275 276

	if (tmp_addr->proto == QETH_PROT_IPV4)
		QETH_CARD_HEX(card, 4, &tmp_addr->u.a4.addr, 4);
277
	else {
278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298
		QETH_CARD_HEX(card, 4, &tmp_addr->u.a6.addr, 8);
		QETH_CARD_HEX(card, 4, ((char *)&tmp_addr->u.a6.addr) + 8, 8);
	}

	addr = qeth_l3_ip_from_hash(card, tmp_addr);
	if (!addr) {
		addr = qeth_l3_get_addr_buffer(tmp_addr->proto);
		if (!addr)
			return -ENOMEM;

		memcpy(addr, tmp_addr, sizeof(struct qeth_ipaddr));
		addr->ref_counter = 1;

		if (addr->type == QETH_IP_TYPE_NORMAL  &&
				qeth_l3_is_addr_covered_by_ipato(card, addr)) {
			QETH_CARD_TEXT(card, 2, "tkovaddr");
			addr->set_flags |= QETH_IPA_SETIP_TAKEOVER_FLAG;
		}
		hash_add(card->ip_htable, &addr->hnode,
				qeth_l3_ipaddr_hash(addr));

299 300 301 302 303
		if (!qeth_card_hw_is_reachable(card)) {
			addr->disp_flag = QETH_DISP_ADDR_ADD;
			return 0;
		}

304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333
		/* qeth_l3_register_addr_entry can go to sleep
		 * if we add a IPV4 addr. It is caused by the reason
		 * that SETIP ipa cmd starts ARP staff for IPV4 addr.
		 * Thus we should unlock spinlock, and make a protection
		 * using in_progress variable to indicate that there is
		 * an hardware operation with this IPV4 address
		 */
		if (addr->proto == QETH_PROT_IPV4) {
			addr->in_progress = 1;
			spin_unlock_bh(&card->ip_lock);
			rc = qeth_l3_register_addr_entry(card, addr);
			spin_lock_bh(&card->ip_lock);
			addr->in_progress = 0;
		} else
			rc = qeth_l3_register_addr_entry(card, addr);

		if (!rc || (rc == IPA_RC_DUPLICATE_IP_ADDRESS) ||
				(rc == IPA_RC_LAN_OFFLINE)) {
			addr->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
			if (addr->ref_counter < 1) {
				qeth_l3_delete_ip(card, addr);
				kfree(addr);
			}
		} else {
			hash_del(&addr->hnode);
			kfree(addr);
		}
	} else {
			if (addr->type == QETH_IP_TYPE_NORMAL)
				addr->ref_counter++;
334
	}
335

336 337 338 339
	return rc;
}


340
struct qeth_ipaddr *qeth_l3_get_addr_buffer(
341 342 343 344 345
				enum qeth_prot_versions prot)
{
	struct qeth_ipaddr *addr;

	addr = kzalloc(sizeof(struct qeth_ipaddr), GFP_ATOMIC);
346
	if (!addr)
347
		return NULL;
348

349
	addr->type = QETH_IP_TYPE_NORMAL;
350
	addr->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
351 352
	addr->proto = prot;

353
	return addr;
354 355
}

356
static void qeth_l3_clear_ip_htable(struct qeth_card *card, int recover)
357 358
{
	struct qeth_ipaddr *addr;
359 360
	struct hlist_node *tmp;
	int i;
361

362
	QETH_CARD_TEXT(card, 4, "clearip");
363

364
	if (recover && card->options.sniffer)
365
		return;
366

367 368 369 370 371 372
	spin_lock_bh(&card->ip_lock);

	hash_for_each_safe(card->ip_htable, i, tmp, addr, hnode) {
		if (!recover) {
			hash_del(&addr->hnode);
			kfree(addr);
373 374
			continue;
		}
375
		addr->disp_flag = QETH_DISP_ADDR_ADD;
376 377
	}

378
	spin_unlock_bh(&card->ip_lock);
379

380 381 382 383
	spin_lock_bh(&card->mclock);

	hash_for_each_safe(card->ip_mc_htable, i, tmp, addr, hnode) {
		hash_del(&addr->hnode);
384 385 386
		kfree(addr);
	}

387 388
	spin_unlock_bh(&card->mclock);

389

390 391
}
static void qeth_l3_recover_ip(struct qeth_card *card)
392
{
393 394 395 396
	struct qeth_ipaddr *addr;
	struct hlist_node *tmp;
	int i;
	int rc;
397

398
	QETH_CARD_TEXT(card, 4, "recovrip");
399 400 401 402

	spin_lock_bh(&card->ip_lock);

	hash_for_each_safe(card->ip_htable, i, tmp, addr, hnode) {
403 404 405 406 407
		if (addr->disp_flag == QETH_DISP_ADDR_DELETE) {
			qeth_l3_deregister_addr_entry(card, addr);
			hash_del(&addr->hnode);
			kfree(addr);
		} else if (addr->disp_flag == QETH_DISP_ADDR_ADD) {
408 409 410 411 412 413 414 415 416 417 418
			if (addr->proto == QETH_PROT_IPV4) {
				addr->in_progress = 1;
				spin_unlock_bh(&card->ip_lock);
				rc = qeth_l3_register_addr_entry(card, addr);
				spin_lock_bh(&card->ip_lock);
				addr->in_progress = 0;
			} else
				rc = qeth_l3_register_addr_entry(card, addr);

			if (!rc) {
				addr->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
419
				if (addr->ref_counter < 1)
420 421 422 423 424 425 426
					qeth_l3_delete_ip(card, addr);
			} else {
				hash_del(&addr->hnode);
				kfree(addr);
			}
		}
	}
427

428
	spin_unlock_bh(&card->ip_lock);
429 430 431 432 433 434 435 436 437 438

}

static int qeth_l3_send_setdelmc(struct qeth_card *card,
			struct qeth_ipaddr *addr, int ipacmd)
{
	int rc;
	struct qeth_cmd_buffer *iob;
	struct qeth_ipa_cmd *cmd;

439
	QETH_CARD_TEXT(card, 4, "setdelmc");
440 441

	iob = qeth_get_ipacmd_buffer(card, ipacmd, addr->proto);
442 443
	if (!iob)
		return -ENOMEM;
444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478
	cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
	memcpy(&cmd->data.setdelipm.mac, addr->mac, OSA_ADDR_LEN);
	if (addr->proto == QETH_PROT_IPV6)
		memcpy(cmd->data.setdelipm.ip6, &addr->u.a6.addr,
		       sizeof(struct in6_addr));
	else
		memcpy(&cmd->data.setdelipm.ip4, &addr->u.a4.addr, 4);

	rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);

	return rc;
}

static void qeth_l3_fill_netmask(u8 *netmask, unsigned int len)
{
	int i, j;
	for (i = 0; i < 16; i++) {
		j = (len) - (i * 8);
		if (j >= 8)
			netmask[i] = 0xff;
		else if (j > 0)
			netmask[i] = (u8)(0xFF00 >> j);
		else
			netmask[i] = 0;
	}
}

static int qeth_l3_send_setdelip(struct qeth_card *card,
		struct qeth_ipaddr *addr, int ipacmd, unsigned int flags)
{
	int rc;
	struct qeth_cmd_buffer *iob;
	struct qeth_ipa_cmd *cmd;
	__u8 netmask[16];

479 480
	QETH_CARD_TEXT(card, 4, "setdelip");
	QETH_CARD_TEXT_(card, 4, "flags%02X", flags);
481 482

	iob = qeth_get_ipacmd_buffer(card, ipacmd, addr->proto);
483 484
	if (!iob)
		return -ENOMEM;
485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510
	cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
	if (addr->proto == QETH_PROT_IPV6) {
		memcpy(cmd->data.setdelip6.ip_addr, &addr->u.a6.addr,
		       sizeof(struct in6_addr));
		qeth_l3_fill_netmask(netmask, addr->u.a6.pfxlen);
		memcpy(cmd->data.setdelip6.mask, netmask,
		       sizeof(struct in6_addr));
		cmd->data.setdelip6.flags = flags;
	} else {
		memcpy(cmd->data.setdelip4.ip_addr, &addr->u.a4.addr, 4);
		memcpy(cmd->data.setdelip4.mask, &addr->u.a4.mask, 4);
		cmd->data.setdelip4.flags = flags;
	}

	rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);

	return rc;
}

static int qeth_l3_send_setrouting(struct qeth_card *card,
	enum qeth_routing_types type, enum qeth_prot_versions prot)
{
	int rc;
	struct qeth_ipa_cmd *cmd;
	struct qeth_cmd_buffer *iob;

511
	QETH_CARD_TEXT(card, 4, "setroutg");
512
	iob = qeth_get_ipacmd_buffer(card, IPA_CMD_SETRTG, prot);
513 514
	if (!iob)
		return -ENOMEM;
515 516 517 518 519 520 521
	cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
	cmd->data.setrtg.type = (type);
	rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);

	return rc;
}

522
static int qeth_l3_correct_routing_type(struct qeth_card *card,
523 524 525 526 527 528 529 530
		enum qeth_routing_types *type, enum qeth_prot_versions prot)
{
	if (card->info.type == QETH_CARD_TYPE_IQD) {
		switch (*type) {
		case NO_ROUTER:
		case PRIMARY_CONNECTOR:
		case SECONDARY_CONNECTOR:
		case MULTICAST_ROUTER:
531
			return 0;
532 533 534 535 536 537 538 539
		default:
			goto out_inval;
		}
	} else {
		switch (*type) {
		case NO_ROUTER:
		case PRIMARY_ROUTER:
		case SECONDARY_ROUTER:
540
			return 0;
541 542 543
		case MULTICAST_ROUTER:
			if (qeth_is_ipafunc_supported(card, prot,
						      IPA_OSA_MC_ROUTER))
544
				return 0;
545 546 547 548 549 550
		default:
			goto out_inval;
		}
	}
out_inval:
	*type = NO_ROUTER;
551
	return -EINVAL;
552 553 554 555 556 557
}

int qeth_l3_setrouting_v4(struct qeth_card *card)
{
	int rc;

558
	QETH_CARD_TEXT(card, 3, "setrtg4");
559

560
	rc = qeth_l3_correct_routing_type(card, &card->options.route4.type,
561
				  QETH_PROT_IPV4);
562 563
	if (rc)
		return rc;
564 565 566 567 568

	rc = qeth_l3_send_setrouting(card, card->options.route4.type,
				  QETH_PROT_IPV4);
	if (rc) {
		card->options.route4.type = NO_ROUTER;
569 570 571
		QETH_DBF_MESSAGE(2, "Error (0x%04x) while setting routing type"
			" on %s. Type set to 'no router'.\n", rc,
			QETH_CARD_IFNAME(card));
572 573 574 575 576 577 578 579
	}
	return rc;
}

int qeth_l3_setrouting_v6(struct qeth_card *card)
{
	int rc = 0;

580
	QETH_CARD_TEXT(card, 3, "setrtg6");
581 582 583 584
#ifdef CONFIG_QETH_IPV6

	if (!qeth_is_supported(card, IPA_IPV6))
		return 0;
585
	rc = qeth_l3_correct_routing_type(card, &card->options.route6.type,
586
				  QETH_PROT_IPV6);
587 588
	if (rc)
		return rc;
589 590 591 592 593

	rc = qeth_l3_send_setrouting(card, card->options.route6.type,
				  QETH_PROT_IPV6);
	if (rc) {
		card->options.route6.type = NO_ROUTER;
594 595 596
		QETH_DBF_MESSAGE(2, "Error (0x%04x) while setting routing type"
			" on %s. Type set to 'no router'.\n", rc,
			QETH_CARD_IFNAME(card));
597 598 599 600 601 602 603 604 605 606 607 608
	}
#endif
	return rc;
}

/*
 * IP address takeover related functions
 */
static void qeth_l3_clear_ipato_list(struct qeth_card *card)
{
	struct qeth_ipato_entry *ipatoe, *tmp;

609 610
	spin_lock_bh(&card->ip_lock);

611 612 613 614
	list_for_each_entry_safe(ipatoe, tmp, &card->ipato.entries, entry) {
		list_del(&ipatoe->entry);
		kfree(ipatoe);
	}
615 616

	spin_unlock_bh(&card->ip_lock);
617 618 619 620 621 622 623 624
}

int qeth_l3_add_ipato_entry(struct qeth_card *card,
				struct qeth_ipato_entry *new)
{
	struct qeth_ipato_entry *ipatoe;
	int rc = 0;

625
	QETH_CARD_TEXT(card, 2, "addipato");
626 627 628

	spin_lock_bh(&card->ip_lock);

629 630 631 632 633 634 635 636 637 638
	list_for_each_entry(ipatoe, &card->ipato.entries, entry) {
		if (ipatoe->proto != new->proto)
			continue;
		if (!memcmp(ipatoe->addr, new->addr,
			    (ipatoe->proto == QETH_PROT_IPV4)? 4:16) &&
		    (ipatoe->mask_bits == new->mask_bits)) {
			rc = -EEXIST;
			break;
		}
	}
639

640 641 642
	if (!rc)
		list_add_tail(&new->entry, &card->ipato.entries);

643 644
	spin_unlock_bh(&card->ip_lock);

645 646 647 648 649 650 651 652
	return rc;
}

void qeth_l3_del_ipato_entry(struct qeth_card *card,
		enum qeth_prot_versions proto, u8 *addr, int mask_bits)
{
	struct qeth_ipato_entry *ipatoe, *tmp;

653
	QETH_CARD_TEXT(card, 2, "delipato");
654 655 656

	spin_lock_bh(&card->ip_lock);

657 658 659 660 661 662 663 664 665 666
	list_for_each_entry_safe(ipatoe, tmp, &card->ipato.entries, entry) {
		if (ipatoe->proto != proto)
			continue;
		if (!memcmp(ipatoe->addr, addr,
			    (proto == QETH_PROT_IPV4)? 4:16) &&
		    (ipatoe->mask_bits == mask_bits)) {
			list_del(&ipatoe->entry);
			kfree(ipatoe);
		}
	}
667 668

	spin_unlock_bh(&card->ip_lock);
669 670 671 672 673 674 675 676 677 678 679 680 681 682
}

/*
 * VIPA related functions
 */
int qeth_l3_add_vipa(struct qeth_card *card, enum qeth_prot_versions proto,
	      const u8 *addr)
{
	struct qeth_ipaddr *ipaddr;
	int rc = 0;

	ipaddr = qeth_l3_get_addr_buffer(proto);
	if (ipaddr) {
		if (proto == QETH_PROT_IPV4) {
683
			QETH_CARD_TEXT(card, 2, "addvipa4");
684 685 686
			memcpy(&ipaddr->u.a4.addr, addr, 4);
			ipaddr->u.a4.mask = 0;
		} else if (proto == QETH_PROT_IPV6) {
687
			QETH_CARD_TEXT(card, 2, "addvipa6");
688 689 690 691 692 693 694 695
			memcpy(&ipaddr->u.a6.addr, addr, 16);
			ipaddr->u.a6.pfxlen = 0;
		}
		ipaddr->type = QETH_IP_TYPE_VIPA;
		ipaddr->set_flags = QETH_IPA_SETIP_VIPA_FLAG;
		ipaddr->del_flags = QETH_IPA_DELIP_VIPA_FLAG;
	} else
		return -ENOMEM;
696 697 698

	spin_lock_bh(&card->ip_lock);

699
	if (qeth_l3_ip_from_hash(card, ipaddr))
700
		rc = -EEXIST;
701 702 703 704 705 706 707
	else
		qeth_l3_add_ip(card, ipaddr);

	spin_unlock_bh(&card->ip_lock);

	kfree(ipaddr);

708 709 710 711 712 713 714 715 716 717 718
	return rc;
}

void qeth_l3_del_vipa(struct qeth_card *card, enum qeth_prot_versions proto,
	      const u8 *addr)
{
	struct qeth_ipaddr *ipaddr;

	ipaddr = qeth_l3_get_addr_buffer(proto);
	if (ipaddr) {
		if (proto == QETH_PROT_IPV4) {
719
			QETH_CARD_TEXT(card, 2, "delvipa4");
720 721 722
			memcpy(&ipaddr->u.a4.addr, addr, 4);
			ipaddr->u.a4.mask = 0;
		} else if (proto == QETH_PROT_IPV6) {
723
			QETH_CARD_TEXT(card, 2, "delvipa6");
724 725 726 727 728 729
			memcpy(&ipaddr->u.a6.addr, addr, 16);
			ipaddr->u.a6.pfxlen = 0;
		}
		ipaddr->type = QETH_IP_TYPE_VIPA;
	} else
		return;
730 731 732 733 734 735

	spin_lock_bh(&card->ip_lock);
	qeth_l3_delete_ip(card, ipaddr);
	spin_unlock_bh(&card->ip_lock);

	kfree(ipaddr);
736 737 738 739 740 741 742 743 744 745 746 747 748 749
}

/*
 * proxy ARP related functions
 */
int qeth_l3_add_rxip(struct qeth_card *card, enum qeth_prot_versions proto,
	      const u8 *addr)
{
	struct qeth_ipaddr *ipaddr;
	int rc = 0;

	ipaddr = qeth_l3_get_addr_buffer(proto);
	if (ipaddr) {
		if (proto == QETH_PROT_IPV4) {
750
			QETH_CARD_TEXT(card, 2, "addrxip4");
751 752 753
			memcpy(&ipaddr->u.a4.addr, addr, 4);
			ipaddr->u.a4.mask = 0;
		} else if (proto == QETH_PROT_IPV6) {
754
			QETH_CARD_TEXT(card, 2, "addrxip6");
755 756 757
			memcpy(&ipaddr->u.a6.addr, addr, 16);
			ipaddr->u.a6.pfxlen = 0;
		}
758

759 760 761 762 763
		ipaddr->type = QETH_IP_TYPE_RXIP;
		ipaddr->set_flags = QETH_IPA_SETIP_TAKEOVER_FLAG;
		ipaddr->del_flags = 0;
	} else
		return -ENOMEM;
764 765 766

	spin_lock_bh(&card->ip_lock);

767
	if (qeth_l3_ip_from_hash(card, ipaddr))
768
		rc = -EEXIST;
769 770 771 772 773 774 775 776
	else
		qeth_l3_add_ip(card, ipaddr);

	spin_unlock_bh(&card->ip_lock);

	kfree(ipaddr);

	return rc;
777 778 779 780 781 782 783 784 785 786
}

void qeth_l3_del_rxip(struct qeth_card *card, enum qeth_prot_versions proto,
			const u8 *addr)
{
	struct qeth_ipaddr *ipaddr;

	ipaddr = qeth_l3_get_addr_buffer(proto);
	if (ipaddr) {
		if (proto == QETH_PROT_IPV4) {
787
			QETH_CARD_TEXT(card, 2, "addrxip4");
788 789 790
			memcpy(&ipaddr->u.a4.addr, addr, 4);
			ipaddr->u.a4.mask = 0;
		} else if (proto == QETH_PROT_IPV6) {
791
			QETH_CARD_TEXT(card, 2, "addrxip6");
792 793 794 795 796 797
			memcpy(&ipaddr->u.a6.addr, addr, 16);
			ipaddr->u.a6.pfxlen = 0;
		}
		ipaddr->type = QETH_IP_TYPE_RXIP;
	} else
		return;
798 799 800 801 802 803

	spin_lock_bh(&card->ip_lock);
	qeth_l3_delete_ip(card, ipaddr);
	spin_unlock_bh(&card->ip_lock);

	kfree(ipaddr);
804 805 806 807 808 809 810 811 812
}

static int qeth_l3_register_addr_entry(struct qeth_card *card,
				struct qeth_ipaddr *addr)
{
	char buf[50];
	int rc = 0;
	int cnt = 3;

813

814
	if (addr->proto == QETH_PROT_IPV4) {
815 816
		QETH_CARD_TEXT(card, 2, "setaddr4");
		QETH_CARD_HEX(card, 3, &addr->u.a4.addr, sizeof(int));
817
	} else if (addr->proto == QETH_PROT_IPV6) {
818 819 820
		QETH_CARD_TEXT(card, 2, "setaddr6");
		QETH_CARD_HEX(card, 3, &addr->u.a6.addr, 8);
		QETH_CARD_HEX(card, 3, ((char *)&addr->u.a6.addr) + 8, 8);
821
	} else {
822 823
		QETH_CARD_TEXT(card, 2, "setaddr?");
		QETH_CARD_HEX(card, 3, addr, sizeof(struct qeth_ipaddr));
824 825 826 827 828 829 830 831
	}
	do {
		if (addr->is_multicast)
			rc =  qeth_l3_send_setdelmc(card, addr, IPA_CMD_SETIPM);
		else
			rc = qeth_l3_send_setdelip(card, addr, IPA_CMD_SETIP,
					addr->set_flags);
		if (rc)
832
			QETH_CARD_TEXT(card, 2, "failed");
833 834
	} while ((--cnt > 0) && rc);
	if (rc) {
835
		QETH_CARD_TEXT(card, 2, "FAILED");
836
		qeth_l3_ipaddr_to_string(addr->proto, (u8 *)&addr->u, buf);
837 838
		dev_warn(&card->gdev->dev,
			"Registering IP address %s failed\n", buf);
839 840 841 842 843 844 845 846 847 848
	}
	return rc;
}

static int qeth_l3_deregister_addr_entry(struct qeth_card *card,
						struct qeth_ipaddr *addr)
{
	int rc = 0;

	if (addr->proto == QETH_PROT_IPV4) {
849 850
		QETH_CARD_TEXT(card, 2, "deladdr4");
		QETH_CARD_HEX(card, 3, &addr->u.a4.addr, sizeof(int));
851
	} else if (addr->proto == QETH_PROT_IPV6) {
852 853 854
		QETH_CARD_TEXT(card, 2, "deladdr6");
		QETH_CARD_HEX(card, 3, &addr->u.a6.addr, 8);
		QETH_CARD_HEX(card, 3, ((char *)&addr->u.a6.addr) + 8, 8);
855
	} else {
856 857
		QETH_CARD_TEXT(card, 2, "deladdr?");
		QETH_CARD_HEX(card, 3, addr, sizeof(struct qeth_ipaddr));
858 859 860 861 862 863
	}
	if (addr->is_multicast)
		rc = qeth_l3_send_setdelmc(card, addr, IPA_CMD_DELIPM);
	else
		rc = qeth_l3_send_setdelip(card, addr, IPA_CMD_DELIP,
					addr->del_flags);
864
	if (rc)
865
		QETH_CARD_TEXT(card, 2, "failed");
866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894

	return rc;
}

static inline u8 qeth_l3_get_qeth_hdr_flags4(int cast_type)
{
	if (cast_type == RTN_MULTICAST)
		return QETH_CAST_MULTICAST;
	if (cast_type == RTN_BROADCAST)
		return QETH_CAST_BROADCAST;
	return QETH_CAST_UNICAST;
}

static inline u8 qeth_l3_get_qeth_hdr_flags6(int cast_type)
{
	u8 ct = QETH_HDR_PASSTHRU | QETH_HDR_IPV6;
	if (cast_type == RTN_MULTICAST)
		return ct | QETH_CAST_MULTICAST;
	if (cast_type == RTN_ANYCAST)
		return ct | QETH_CAST_ANYCAST;
	if (cast_type == RTN_BROADCAST)
		return ct | QETH_CAST_BROADCAST;
	return ct | QETH_CAST_UNICAST;
}

static int qeth_l3_setadapter_parms(struct qeth_card *card)
{
	int rc;

895
	QETH_DBF_TEXT(SETUP, 2, "setadprm");
896 897

	if (!qeth_is_supported(card, IPA_SETADAPTERPARMS)) {
898 899
		dev_info(&card->gdev->dev,
			"set adapter parameters not supported.\n");
900
		QETH_DBF_TEXT(SETUP, 2, " notsupp");
901 902 903 904
		return 0;
	}
	rc = qeth_query_setadapterparms(card);
	if (rc) {
905
		QETH_DBF_MESSAGE(2, "%s couldn't set adapter parameters: "
906
			"0x%x\n", dev_name(&card->gdev->dev), rc);
907 908 909 910 911
		return rc;
	}
	if (qeth_adp_supported(card, IPA_SETADP_ALTER_MAC_ADDRESS)) {
		rc = qeth_setadpparms_change_macaddr(card);
		if (rc)
912
			dev_warn(&card->gdev->dev, "Reading the adapter MAC"
913
				" address failed\n");
914 915 916 917 918 919 920 921 922 923 924 925
	}

	return rc;
}

#ifdef CONFIG_QETH_IPV6
static int qeth_l3_send_simple_setassparms_ipv6(struct qeth_card *card,
		enum qeth_ipa_funcs ipa_func, __u16 cmd_code)
{
	int rc;
	struct qeth_cmd_buffer *iob;

926
	QETH_CARD_TEXT(card, 4, "simassp6");
927
	iob = qeth_get_setassparms_cmd(card, ipa_func, cmd_code,
928
				       0, QETH_PROT_IPV6);
929 930
	if (!iob)
		return -ENOMEM;
931
	rc = qeth_send_setassparms(card, iob, 0, 0,
932
				   qeth_setassparms_cb, NULL);
933 934 935 936 937 938 939 940
	return rc;
}
#endif

static int qeth_l3_start_ipa_arp_processing(struct qeth_card *card)
{
	int rc;

941
	QETH_CARD_TEXT(card, 3, "ipaarp");
942 943

	if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
944 945 946
		dev_info(&card->gdev->dev,
			"ARP processing not supported on %s!\n",
			QETH_CARD_IFNAME(card));
947 948
		return 0;
	}
949 950
	rc = qeth_send_simple_setassparms(card, IPA_ARP_PROCESSING,
					  IPA_CMD_ASS_START, 0);
951
	if (rc) {
952 953 954
		dev_warn(&card->gdev->dev,
			"Starting ARP processing support for %s failed\n",
			QETH_CARD_IFNAME(card));
955 956 957 958 959 960 961 962
	}
	return rc;
}

static int qeth_l3_start_ipa_source_mac(struct qeth_card *card)
{
	int rc;

963
	QETH_CARD_TEXT(card, 3, "stsrcmac");
964 965

	if (!qeth_is_supported(card, IPA_SOURCE_MAC)) {
966
		dev_info(&card->gdev->dev,
967
			"Inbound source MAC-address not supported on %s\n",
968
			QETH_CARD_IFNAME(card));
969 970 971
		return -EOPNOTSUPP;
	}

972
	rc = qeth_send_simple_setassparms(card, IPA_SOURCE_MAC,
973 974
					  IPA_CMD_ASS_START, 0);
	if (rc)
975
		dev_warn(&card->gdev->dev,
976
			"Starting source MAC-address support for %s failed\n",
977
			QETH_CARD_IFNAME(card));
978 979 980 981 982 983 984
	return rc;
}

static int qeth_l3_start_ipa_vlan(struct qeth_card *card)
{
	int rc = 0;

985
	QETH_CARD_TEXT(card, 3, "strtvlan");
986 987

	if (!qeth_is_supported(card, IPA_FULL_VLAN)) {
988 989
		dev_info(&card->gdev->dev,
			"VLAN not supported on %s\n", QETH_CARD_IFNAME(card));
990 991 992
		return -EOPNOTSUPP;
	}

993
	rc = qeth_send_simple_setassparms(card, IPA_VLAN_PRIO,
994 995
					  IPA_CMD_ASS_START, 0);
	if (rc) {
996 997 998
		dev_warn(&card->gdev->dev,
			"Starting VLAN support for %s failed\n",
			QETH_CARD_IFNAME(card));
999
	} else {
1000
		dev_info(&card->gdev->dev, "VLAN enabled\n");
1001 1002 1003 1004 1005 1006 1007 1008
	}
	return rc;
}

static int qeth_l3_start_ipa_multicast(struct qeth_card *card)
{
	int rc;

1009
	QETH_CARD_TEXT(card, 3, "stmcast");
1010 1011

	if (!qeth_is_supported(card, IPA_MULTICASTING)) {
1012 1013 1014
		dev_info(&card->gdev->dev,
			"Multicast not supported on %s\n",
			QETH_CARD_IFNAME(card));
1015 1016 1017
		return -EOPNOTSUPP;
	}

1018
	rc = qeth_send_simple_setassparms(card, IPA_MULTICASTING,
1019 1020
					  IPA_CMD_ASS_START, 0);
	if (rc) {
1021 1022 1023
		dev_warn(&card->gdev->dev,
			"Starting multicast support for %s failed\n",
			QETH_CARD_IFNAME(card));
1024
	} else {
1025
		dev_info(&card->gdev->dev, "Multicast enabled\n");
1026 1027 1028 1029 1030 1031 1032 1033 1034 1035
		card->dev->flags |= IFF_MULTICAST;
	}
	return rc;
}

#ifdef CONFIG_QETH_IPV6
static int qeth_l3_softsetup_ipv6(struct qeth_card *card)
{
	int rc;

1036
	QETH_CARD_TEXT(card, 3, "softipv6");
1037

1038
	rc = qeth_query_ipassists(card, QETH_PROT_IPV6);
1039
	if (rc) {
1040 1041 1042
		dev_err(&card->gdev->dev,
			"Activating IPv6 support for %s failed\n",
			QETH_CARD_IFNAME(card));
1043 1044
		return rc;
	}
1045 1046 1047 1048

	if (card->info.type == QETH_CARD_TYPE_IQD)
		goto out;

1049
	rc = qeth_send_simple_setassparms(card, IPA_IPV6,
1050 1051
					  IPA_CMD_ASS_START, 3);
	if (rc) {
1052 1053 1054
		dev_err(&card->gdev->dev,
			"Activating IPv6 support for %s failed\n",
			QETH_CARD_IFNAME(card));
1055 1056 1057 1058 1059
		return rc;
	}
	rc = qeth_l3_send_simple_setassparms_ipv6(card, IPA_IPV6,
					       IPA_CMD_ASS_START);
	if (rc) {
1060 1061 1062
		dev_err(&card->gdev->dev,
			"Activating IPv6 support for %s failed\n",
			 QETH_CARD_IFNAME(card));
1063 1064 1065 1066 1067
		return rc;
	}
	rc = qeth_l3_send_simple_setassparms_ipv6(card, IPA_PASSTHRU,
					       IPA_CMD_ASS_START);
	if (rc) {
1068 1069 1070
		dev_warn(&card->gdev->dev,
			"Enabling the passthrough mode for %s failed\n",
			QETH_CARD_IFNAME(card));
1071 1072 1073
		return rc;
	}
out:
1074
	dev_info(&card->gdev->dev, "IPV6 enabled\n");
1075 1076 1077 1078 1079 1080 1081 1082
	return 0;
}
#endif

static int qeth_l3_start_ipa_ipv6(struct qeth_card *card)
{
	int rc = 0;

1083
	QETH_CARD_TEXT(card, 3, "strtipv6");
1084 1085

	if (!qeth_is_supported(card, IPA_IPV6)) {
1086 1087
		dev_info(&card->gdev->dev,
			"IPv6 not supported on %s\n", QETH_CARD_IFNAME(card));
1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099
		return 0;
	}
#ifdef CONFIG_QETH_IPV6
	rc = qeth_l3_softsetup_ipv6(card);
#endif
	return rc ;
}

static int qeth_l3_start_ipa_broadcast(struct qeth_card *card)
{
	int rc;

1100
	QETH_CARD_TEXT(card, 3, "stbrdcst");
1101 1102
	card->info.broadcast_capable = 0;
	if (!qeth_is_supported(card, IPA_FILTERING)) {
1103 1104 1105
		dev_info(&card->gdev->dev,
			"Broadcast not supported on %s\n",
			QETH_CARD_IFNAME(card));
1106 1107 1108
		rc = -EOPNOTSUPP;
		goto out;
	}
1109
	rc = qeth_send_simple_setassparms(card, IPA_FILTERING,
1110 1111
					  IPA_CMD_ASS_START, 0);
	if (rc) {
1112 1113
		dev_warn(&card->gdev->dev, "Enabling broadcast filtering for "
			"%s failed\n", QETH_CARD_IFNAME(card));
1114 1115 1116
		goto out;
	}

1117
	rc = qeth_send_simple_setassparms(card, IPA_FILTERING,
1118 1119
					  IPA_CMD_ASS_CONFIGURE, 1);
	if (rc) {
1120 1121 1122
		dev_warn(&card->gdev->dev,
			"Setting up broadcast filtering for %s failed\n",
			QETH_CARD_IFNAME(card));
1123 1124 1125
		goto out;
	}
	card->info.broadcast_capable = QETH_BROADCAST_WITH_ECHO;
1126
	dev_info(&card->gdev->dev, "Broadcast enabled\n");
1127
	rc = qeth_send_simple_setassparms(card, IPA_FILTERING,
1128 1129
					  IPA_CMD_ASS_ENABLE, 1);
	if (rc) {
1130 1131
		dev_warn(&card->gdev->dev, "Setting up broadcast echo "
			"filtering for %s failed\n", QETH_CARD_IFNAME(card));
1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144
		goto out;
	}
	card->info.broadcast_capable = QETH_BROADCAST_WITHOUT_ECHO;
out:
	if (card->info.broadcast_capable)
		card->dev->flags |= IFF_BROADCAST;
	else
		card->dev->flags &= ~IFF_BROADCAST;
	return rc;
}

static int qeth_l3_start_ipassists(struct qeth_card *card)
{
1145
	QETH_CARD_TEXT(card, 3, "strtipas");
1146

S
Stefan Raspl 已提交
1147 1148
	if (qeth_set_access_ctrl_online(card, 0))
		return -EIO;
1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167
	qeth_l3_start_ipa_arp_processing(card);	/* go on*/
	qeth_l3_start_ipa_source_mac(card);	/* go on*/
	qeth_l3_start_ipa_vlan(card);		/* go on*/
	qeth_l3_start_ipa_multicast(card);		/* go on*/
	qeth_l3_start_ipa_ipv6(card);		/* go on*/
	qeth_l3_start_ipa_broadcast(card);		/* go on*/
	return 0;
}

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

	cmd = (struct qeth_ipa_cmd *) data;
	if (cmd->hdr.return_code == 0)
		memcpy(card->dev->dev_addr,
			cmd->data.create_destroy_addr.unique_id, ETH_ALEN);
	else
J
Joe Perches 已提交
1168
		eth_random_addr(card->dev->dev_addr);
1169 1170 1171 1172 1173 1174 1175 1176 1177 1178

	return 0;
}

static int qeth_l3_iqd_read_initial_mac(struct qeth_card *card)
{
	int rc = 0;
	struct qeth_cmd_buffer *iob;
	struct qeth_ipa_cmd *cmd;

1179
	QETH_DBF_TEXT(SETUP, 2, "hsrmac");
1180 1181 1182

	iob = qeth_get_ipacmd_buffer(card, IPA_CMD_CREATE_ADDR,
				     QETH_PROT_IPV6);
1183 1184
	if (!iob)
		return -ENOMEM;
1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205
	cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
	*((__u16 *) &cmd->data.create_destroy_addr.unique_id[6]) =
			card->info.unique_id;

	rc = qeth_send_ipa_cmd(card, iob, qeth_l3_iqd_read_initial_mac_cb,
				NULL);
	return rc;
}

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

	cmd = (struct qeth_ipa_cmd *) data;
	if (cmd->hdr.return_code == 0)
		card->info.unique_id = *((__u16 *)
				&cmd->data.create_destroy_addr.unique_id[6]);
	else {
		card->info.unique_id =  UNIQUE_ID_IF_CREATE_ADDR_FAILED |
					UNIQUE_ID_NOT_BY_CARD;
1206 1207
		dev_warn(&card->gdev->dev, "The network adapter failed to "
			"generate a unique ID\n");
1208 1209 1210 1211 1212 1213 1214 1215 1216 1217
	}
	return 0;
}

static int qeth_l3_get_unique_id(struct qeth_card *card)
{
	int rc = 0;
	struct qeth_cmd_buffer *iob;
	struct qeth_ipa_cmd *cmd;

1218
	QETH_DBF_TEXT(SETUP, 2, "guniqeid");
1219 1220 1221 1222 1223 1224 1225 1226 1227

	if (!qeth_is_supported(card, IPA_IPV6)) {
		card->info.unique_id =  UNIQUE_ID_IF_CREATE_ADDR_FAILED |
					UNIQUE_ID_NOT_BY_CARD;
		return 0;
	}

	iob = qeth_get_ipacmd_buffer(card, IPA_CMD_CREATE_ADDR,
				     QETH_PROT_IPV6);
1228 1229
	if (!iob)
		return -ENOMEM;
1230 1231 1232 1233 1234 1235 1236 1237
	cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
	*((__u16 *) &cmd->data.create_destroy_addr.unique_id[6]) =
			card->info.unique_id;

	rc = qeth_send_ipa_cmd(card, iob, qeth_l3_get_unique_id_cb, NULL);
	return rc;
}

1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248
static int
qeth_diags_trace_cb(struct qeth_card *card, struct qeth_reply *reply,
			    unsigned long data)
{
	struct qeth_ipa_cmd	   *cmd;
	__u16 rc;

	QETH_DBF_TEXT(SETUP, 2, "diastrcb");

	cmd = (struct qeth_ipa_cmd *)data;
	rc = cmd->hdr.return_code;
1249
	if (rc)
1250
		QETH_CARD_TEXT_(card, 2, "dxter%x", rc);
1251 1252 1253 1254
	switch (cmd->data.diagass.action) {
	case QETH_DIAGS_CMD_TRACE_QUERY:
		break;
	case QETH_DIAGS_CMD_TRACE_DISABLE:
1255 1256 1257 1258 1259 1260 1261 1262 1263 1264
		switch (rc) {
		case 0:
		case IPA_RC_INVALID_SUBCMD:
			card->info.promisc_mode = SET_PROMISC_MODE_OFF;
			dev_info(&card->gdev->dev, "The HiperSockets network "
				"traffic analyzer is deactivated\n");
			break;
		default:
			break;
		}
1265 1266
		break;
	case QETH_DIAGS_CMD_TRACE_ENABLE:
1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285
		switch (rc) {
		case 0:
			card->info.promisc_mode = SET_PROMISC_MODE_ON;
			dev_info(&card->gdev->dev, "The HiperSockets network "
				"traffic analyzer is activated\n");
			break;
		case IPA_RC_HARDWARE_AUTH_ERROR:
			dev_warn(&card->gdev->dev, "The device is not "
				"authorized to run as a HiperSockets network "
				"traffic analyzer\n");
			break;
		case IPA_RC_TRACE_ALREADY_ACTIVE:
			dev_warn(&card->gdev->dev, "A HiperSockets "
				"network traffic analyzer is already "
				"active in the HiperSockets LAN\n");
			break;
		default:
			break;
		}
1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303
		break;
	default:
		QETH_DBF_MESSAGE(2, "Unknown sniffer action (0x%04x) on %s\n",
			cmd->data.diagass.action, QETH_CARD_IFNAME(card));
	}

	return 0;
}

static int
qeth_diags_trace(struct qeth_card *card, enum qeth_diags_trace_cmds diags_cmd)
{
	struct qeth_cmd_buffer *iob;
	struct qeth_ipa_cmd    *cmd;

	QETH_DBF_TEXT(SETUP, 2, "diagtrac");

	iob = qeth_get_ipacmd_buffer(card, IPA_CMD_SET_DIAG_ASS, 0);
1304 1305
	if (!iob)
		return -ENOMEM;
1306 1307 1308 1309 1310 1311 1312 1313
	cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
	cmd->data.diagass.subcmd_len = 16;
	cmd->data.diagass.subcmd = QETH_DIAGS_CMD_TRACE;
	cmd->data.diagass.type = QETH_DIAGS_TYPE_HIPERSOCKET;
	cmd->data.diagass.action = diags_cmd;
	return qeth_send_ipa_cmd(card, iob, qeth_diags_trace_cb, NULL);
}

1314
static void qeth_l3_get_mac_for_ipm(__be32 ipm, char *mac)
1315
{
1316
	ip_eth_mc_map(ipm, mac);
1317 1318
}

1319 1320 1321 1322 1323 1324 1325 1326 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 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371
static void qeth_l3_mark_all_mc_to_be_deleted(struct qeth_card *card)
{
	struct qeth_ipaddr *addr;
	int i;

	hash_for_each(card->ip_mc_htable, i, addr, hnode)
		addr->disp_flag = QETH_DISP_ADDR_DELETE;

}

static void qeth_l3_add_all_new_mc(struct qeth_card *card)
{
	struct qeth_ipaddr *addr;
	struct hlist_node *tmp;
	int i;
	int rc;

	hash_for_each_safe(card->ip_mc_htable, i, tmp, addr, hnode) {
		if (addr->disp_flag == QETH_DISP_ADDR_ADD) {
			rc = qeth_l3_register_addr_entry(card, addr);
			if (!rc || (rc == IPA_RC_LAN_OFFLINE))
				addr->ref_counter = 1;
			else {
				hash_del(&addr->hnode);
				kfree(addr);
			}
		}
	}

}

static void qeth_l3_delete_nonused_mc(struct qeth_card *card)
{
	struct qeth_ipaddr *addr;
	struct hlist_node *tmp;
	int i;
	int rc;

	hash_for_each_safe(card->ip_mc_htable, i, tmp, addr, hnode) {
		if (addr->disp_flag == QETH_DISP_ADDR_DELETE) {
			rc = qeth_l3_deregister_addr_entry(card, addr);
			if (!rc || (rc == IPA_RC_MC_ADDR_NOT_FOUND)) {
				hash_del(&addr->hnode);
				kfree(addr);
			}
		}
	}

}


static void
qeth_l3_add_mc_to_hash(struct qeth_card *card, struct in_device *in4_dev)
1372 1373
{
	struct ip_mc_list *im4;
1374
	struct qeth_ipaddr *tmp, *ipm;
1375 1376
	char buf[MAX_ADDR_LEN];

1377
	QETH_CARD_TEXT(card, 4, "addmc");
1378 1379 1380 1381 1382

	tmp = qeth_l3_get_addr_buffer(QETH_PROT_IPV4);
		if (!tmp)
			return;

1383 1384
	for (im4 = rcu_dereference(in4_dev->mc_list); im4 != NULL;
	     im4 = rcu_dereference(im4->next_rcu)) {
1385 1386
		qeth_l3_get_mac_for_ipm(im4->multiaddr, buf);

1387
		tmp->u.a4.addr = be32_to_cpu(im4->multiaddr);
1388 1389 1390 1391 1392 1393 1394 1395 1396 1397
		memcpy(tmp->mac, buf, sizeof(tmp->mac));

		ipm = qeth_l3_ip_from_hash(card, tmp);
		if (ipm) {
			ipm->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
		} else {
			ipm = qeth_l3_get_addr_buffer(QETH_PROT_IPV4);
			if (!ipm)
				continue;
			memcpy(ipm->mac, buf, sizeof(tmp->mac));
1398
			ipm->u.a4.addr = be32_to_cpu(im4->multiaddr);
1399 1400 1401 1402 1403
			ipm->is_multicast = 1;
			ipm->disp_flag = QETH_DISP_ADDR_ADD;
			hash_add(card->ip_mc_htable,
					&ipm->hnode, qeth_l3_ipaddr_hash(ipm));
		}
1404
	}
1405 1406

	kfree(tmp);
1407 1408
}

1409
/* called with rcu_read_lock */
1410 1411 1412
static void qeth_l3_add_vlan_mc(struct qeth_card *card)
{
	struct in_device *in_dev;
J
Jiri Pirko 已提交
1413
	u16 vid;
1414

1415
	QETH_CARD_TEXT(card, 4, "addmcvl");
1416

J
Jiri Pirko 已提交
1417
	if (!qeth_is_supported(card, IPA_FULL_VLAN))
1418 1419
		return;

J
Jiri Pirko 已提交
1420 1421 1422
	for_each_set_bit(vid, card->active_vlans, VLAN_N_VID) {
		struct net_device *netdev;

1423
		netdev = __vlan_find_dev_deep_rcu(card->dev, htons(ETH_P_8021Q),
1424
					      vid);
1425 1426 1427
		if (netdev == NULL ||
		    !(netdev->flags & IFF_UP))
			continue;
1428
		in_dev = __in_dev_get_rcu(netdev);
1429 1430
		if (!in_dev)
			continue;
1431
		qeth_l3_add_mc_to_hash(card, in_dev);
1432 1433 1434 1435 1436 1437 1438
	}
}

static void qeth_l3_add_multicast_ipv4(struct qeth_card *card)
{
	struct in_device *in4_dev;

1439
	QETH_CARD_TEXT(card, 4, "chkmcv4");
1440

1441
	rcu_read_lock();
1442 1443 1444
	in4_dev = __in_dev_get_rcu(card->dev);
	if (in4_dev == NULL)
		goto unlock;
1445
	qeth_l3_add_mc_to_hash(card, in4_dev);
1446
	qeth_l3_add_vlan_mc(card);
1447
unlock:
1448
	rcu_read_unlock();
1449 1450 1451
}

#ifdef CONFIG_QETH_IPV6
1452 1453
static void
qeth_l3_add_mc6_to_hash(struct qeth_card *card, struct inet6_dev *in6_dev)
1454 1455 1456
{
	struct qeth_ipaddr *ipm;
	struct ifmcaddr6 *im6;
1457
	struct qeth_ipaddr *tmp;
1458 1459
	char buf[MAX_ADDR_LEN];

1460
	QETH_CARD_TEXT(card, 4, "addmc6");
1461 1462 1463 1464 1465

	tmp = qeth_l3_get_addr_buffer(QETH_PROT_IPV6);
		if (!tmp)
			return;

1466 1467
	for (im6 = in6_dev->mc_list; im6 != NULL; im6 = im6->next) {
		ndisc_mc_map(&im6->mca_addr, buf, in6_dev->dev, 0);
1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479

		memcpy(tmp->mac, buf, sizeof(tmp->mac));
		memcpy(&tmp->u.a6.addr, &im6->mca_addr.s6_addr,
		       sizeof(struct in6_addr));
		tmp->is_multicast = 1;

		ipm = qeth_l3_ip_from_hash(card, tmp);
		if (ipm) {
			ipm->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
			continue;
		}

1480 1481 1482
		ipm = qeth_l3_get_addr_buffer(QETH_PROT_IPV6);
		if (!ipm)
			continue;
1483

1484 1485 1486
		memcpy(ipm->mac, buf, OSA_ADDR_LEN);
		memcpy(&ipm->u.a6.addr, &im6->mca_addr.s6_addr,
		       sizeof(struct in6_addr));
1487 1488 1489 1490 1491
		ipm->is_multicast = 1;
		ipm->disp_flag = QETH_DISP_ADDR_ADD;
		hash_add(card->ip_mc_htable,
				&ipm->hnode, qeth_l3_ipaddr_hash(ipm));

1492
	}
1493
	kfree(tmp);
1494 1495
}

1496
/* called with rcu_read_lock */
1497 1498 1499
static void qeth_l3_add_vlan_mc6(struct qeth_card *card)
{
	struct inet6_dev *in_dev;
J
Jiri Pirko 已提交
1500
	u16 vid;
1501

1502
	QETH_CARD_TEXT(card, 4, "admc6vl");
1503

J
Jiri Pirko 已提交
1504
	if (!qeth_is_supported(card, IPA_FULL_VLAN))
1505 1506
		return;

J
Jiri Pirko 已提交
1507 1508 1509
	for_each_set_bit(vid, card->active_vlans, VLAN_N_VID) {
		struct net_device *netdev;

1510
		netdev = __vlan_find_dev_deep_rcu(card->dev, htons(ETH_P_8021Q),
1511
					      vid);
1512 1513 1514 1515 1516 1517 1518
		if (netdev == NULL ||
		    !(netdev->flags & IFF_UP))
			continue;
		in_dev = in6_dev_get(netdev);
		if (!in_dev)
			continue;
		read_lock_bh(&in_dev->lock);
1519
		qeth_l3_add_mc6_to_hash(card, in_dev);
1520 1521 1522 1523 1524 1525 1526 1527 1528
		read_unlock_bh(&in_dev->lock);
		in6_dev_put(in_dev);
	}
}

static void qeth_l3_add_multicast_ipv6(struct qeth_card *card)
{
	struct inet6_dev *in6_dev;

1529
	QETH_CARD_TEXT(card, 4, "chkmcv6");
1530

1531 1532 1533
	if (!qeth_is_supported(card, IPA_IPV6))
		return ;
	in6_dev = in6_dev_get(card->dev);
1534
	if (!in6_dev)
1535
		return;
1536

1537
	rcu_read_lock();
1538
	read_lock_bh(&in6_dev->lock);
1539
	qeth_l3_add_mc6_to_hash(card, in6_dev);
1540 1541
	qeth_l3_add_vlan_mc6(card);
	read_unlock_bh(&in6_dev->lock);
1542
	rcu_read_unlock();
1543 1544 1545 1546 1547 1548 1549 1550 1551 1552
	in6_dev_put(in6_dev);
}
#endif /* CONFIG_QETH_IPV6 */

static void qeth_l3_free_vlan_addresses4(struct qeth_card *card,
			unsigned short vid)
{
	struct in_device *in_dev;
	struct in_ifaddr *ifa;
	struct qeth_ipaddr *addr;
J
Jiri Pirko 已提交
1553
	struct net_device *netdev;
1554

1555
	QETH_CARD_TEXT(card, 4, "frvaddr4");
1556

1557
	netdev = __vlan_find_dev_deep_rcu(card->dev, htons(ETH_P_8021Q), vid);
1558 1559
	if (!netdev)
		return;
J
Jiri Pirko 已提交
1560
	in_dev = in_dev_get(netdev);
1561 1562
	if (!in_dev)
		return;
1563 1564 1565 1566 1567 1568 1569

	addr = qeth_l3_get_addr_buffer(QETH_PROT_IPV4);
	if (!addr)
		return;

	spin_lock_bh(&card->ip_lock);

1570
	for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
1571 1572
		addr->u.a4.addr = be32_to_cpu(ifa->ifa_address);
		addr->u.a4.mask = be32_to_cpu(ifa->ifa_mask);
1573 1574
		addr->type = QETH_IP_TYPE_NORMAL;
		qeth_l3_delete_ip(card, addr);
1575
	}
1576 1577 1578 1579

	spin_unlock_bh(&card->ip_lock);

	kfree(addr);
1580 1581 1582 1583 1584 1585 1586 1587 1588 1589
	in_dev_put(in_dev);
}

static void qeth_l3_free_vlan_addresses6(struct qeth_card *card,
			unsigned short vid)
{
#ifdef CONFIG_QETH_IPV6
	struct inet6_dev *in6_dev;
	struct inet6_ifaddr *ifa;
	struct qeth_ipaddr *addr;
J
Jiri Pirko 已提交
1590
	struct net_device *netdev;
1591

1592
	QETH_CARD_TEXT(card, 4, "frvaddr6");
1593

1594
	netdev = __vlan_find_dev_deep_rcu(card->dev, htons(ETH_P_8021Q), vid);
1595 1596
	if (!netdev)
		return;
1597

J
Jiri Pirko 已提交
1598
	in6_dev = in6_dev_get(netdev);
1599 1600
	if (!in6_dev)
		return;
1601 1602 1603 1604 1605 1606 1607

	addr = qeth_l3_get_addr_buffer(QETH_PROT_IPV6);
	if (!addr)
		return;

	spin_lock_bh(&card->ip_lock);

1608
	list_for_each_entry(ifa, &in6_dev->addr_list, if_list) {
1609 1610 1611 1612 1613
		memcpy(&addr->u.a6.addr, &ifa->addr,
		       sizeof(struct in6_addr));
		addr->u.a6.pfxlen = ifa->prefix_len;
		addr->type = QETH_IP_TYPE_NORMAL;
		qeth_l3_delete_ip(card, addr);
1614
	}
1615 1616 1617 1618

	spin_unlock_bh(&card->ip_lock);

	kfree(addr);
1619 1620 1621 1622 1623 1624 1625
	in6_dev_put(in6_dev);
#endif /* CONFIG_QETH_IPV6 */
}

static void qeth_l3_free_vlan_addresses(struct qeth_card *card,
			unsigned short vid)
{
1626
	rcu_read_lock();
1627 1628
	qeth_l3_free_vlan_addresses4(card, vid);
	qeth_l3_free_vlan_addresses6(card, vid);
1629
	rcu_read_unlock();
1630 1631
}

1632 1633
static int qeth_l3_vlan_rx_add_vid(struct net_device *dev,
				   __be16 proto, u16 vid)
1634
{
1635
	struct qeth_card *card = dev->ml_priv;
1636

J
Jiri Pirko 已提交
1637
	set_bit(vid, card->active_vlans);
1638
	return 0;
1639 1640
}

1641 1642
static int qeth_l3_vlan_rx_kill_vid(struct net_device *dev,
				    __be16 proto, u16 vid)
1643
{
1644
	struct qeth_card *card = dev->ml_priv;
1645

1646
	QETH_CARD_TEXT_(card, 4, "kid:%d", vid);
1647

1648
	if (qeth_wait_for_threads(card, QETH_RECOVER_THREAD)) {
1649
		QETH_CARD_TEXT(card, 3, "kidREC");
1650
		return 0;
1651
	}
1652 1653
	/* unregister IP addresses of vlan device */
	qeth_l3_free_vlan_addresses(card, vid);
J
Jiri Pirko 已提交
1654
	clear_bit(vid, card->active_vlans);
1655
	qeth_l3_set_multicast_list(card->dev);
1656
	return 0;
1657 1658
}

1659 1660 1661
static inline int qeth_l3_rebuild_skb(struct qeth_card *card,
			struct sk_buff *skb, struct qeth_hdr *hdr,
			unsigned short *vlan_id)
1662
{
1663
	__u16 prot;
1664 1665
	struct iphdr *ip_hdr;
	unsigned char tg_addr[MAX_ADDR_LEN];
1666
	int is_vlan = 0;
1667 1668

	if (!(hdr->hdr.l3.flags & QETH_HDR_PASSTHRU)) {
1669 1670
		prot = (hdr->hdr.l3.flags & QETH_HDR_IPV6) ? ETH_P_IPV6 :
			      ETH_P_IP;
1671 1672 1673 1674
		switch (hdr->hdr.l3.flags & QETH_HDR_CAST_MASK) {
		case QETH_CAST_MULTICAST:
			switch (prot) {
#ifdef CONFIG_QETH_IPV6
1675
			case ETH_P_IPV6:
1676 1677 1678 1679 1680
				ndisc_mc_map((struct in6_addr *)
				     skb->data + 24,
				     tg_addr, card->dev, 0);
				break;
#endif
1681
			case ETH_P_IP:
1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701
				ip_hdr = (struct iphdr *)skb->data;
				ip_eth_mc_map(ip_hdr->daddr, tg_addr);
				break;
			default:
				memcpy(tg_addr, card->dev->broadcast,
					card->dev->addr_len);
			}
			card->stats.multicast++;
			skb->pkt_type = PACKET_MULTICAST;
			break;
		case QETH_CAST_BROADCAST:
			memcpy(tg_addr, card->dev->broadcast,
				card->dev->addr_len);
			card->stats.multicast++;
			skb->pkt_type = PACKET_BROADCAST;
			break;
		case QETH_CAST_UNICAST:
		case QETH_CAST_ANYCAST:
		case QETH_CAST_NOCAST:
		default:
1702 1703 1704 1705
			if (card->options.sniffer)
				skb->pkt_type = PACKET_OTHERHOST;
			else
				skb->pkt_type = PACKET_HOST;
1706 1707 1708
			memcpy(tg_addr, card->dev->dev_addr,
				card->dev->addr_len);
		}
1709 1710 1711 1712 1713 1714 1715
		if (hdr->hdr.l3.ext_flags & QETH_HDR_EXT_SRC_MAC_ADDR)
			card->dev->header_ops->create(skb, card->dev, prot,
				tg_addr, &hdr->hdr.l3.dest_addr[2],
				card->dev->addr_len);
		else
			card->dev->header_ops->create(skb, card->dev, prot,
				tg_addr, "FAKELL", card->dev->addr_len);
1716 1717
	}

1718
	skb->protocol = eth_type_trans(skb, card->dev);
1719 1720 1721

	if (hdr->hdr.l3.ext_flags &
	    (QETH_HDR_EXT_VLAN_FRAME | QETH_HDR_EXT_INCLUDE_VLAN_TAG)) {
1722
		*vlan_id = (hdr->hdr.l3.ext_flags & QETH_HDR_EXT_VLAN_FRAME) ?
1723
		 hdr->hdr.l3.vlan_id : *((u16 *)&hdr->hdr.l3.dest_addr[12]);
1724
		is_vlan = 1;
1725 1726
	}

1727
	if (card->dev->features & NETIF_F_RXCSUM) {
1728
		if ((hdr->hdr.l3.ext_flags &
1729 1730 1731 1732
		    (QETH_HDR_EXT_CSUM_HDR_REQ |
		     QETH_HDR_EXT_CSUM_TRANSP_REQ)) ==
		    (QETH_HDR_EXT_CSUM_HDR_REQ |
		     QETH_HDR_EXT_CSUM_TRANSP_REQ))
1733 1734
			skb->ip_summed = CHECKSUM_UNNECESSARY;
		else
1735
			skb->ip_summed = CHECKSUM_NONE;
1736 1737
	} else
		skb->ip_summed = CHECKSUM_NONE;
1738
	return is_vlan;
1739 1740
}

1741 1742
static int qeth_l3_process_inbound_buffer(struct qeth_card *card,
				int budget, int *done)
1743
{
1744
	int work_done = 0;
1745 1746 1747
	struct sk_buff *skb;
	struct qeth_hdr *hdr;
	__u16 vlan_tag = 0;
1748
	int is_vlan;
1749
	unsigned int len;
1750
	__u16 magic;
1751

1752
	*done = 0;
S
Stefan Raspl 已提交
1753
	WARN_ON_ONCE(!budget);
1754 1755
	while (budget) {
		skb = qeth_core_get_next_skb(card,
1756
			&card->qdio.in_q->bufs[card->rx.b_index],
1757 1758 1759 1760 1761 1762
			&card->rx.b_element, &card->rx.e_offset, &hdr);
		if (!skb) {
			*done = 1;
			break;
		}
		skb->dev = card->dev;
1763 1764
		switch (hdr->hdr.l3.id) {
		case QETH_HEADER_TYPE_LAYER3:
1765 1766 1767
			magic = *(__u16 *)skb->data;
			if ((card->info.type == QETH_CARD_TYPE_IQD) &&
			    (magic == ETH_P_AF_IUCV)) {
1768
				skb->protocol = cpu_to_be16(ETH_P_AF_IUCV);
1769 1770 1771 1772 1773 1774 1775 1776 1777 1778
				skb->pkt_type = PACKET_HOST;
				skb->mac_header = NET_SKB_PAD;
				skb->dev = card->dev;
				len = skb->len;
				card->dev->header_ops->create(skb, card->dev, 0,
					card->dev->dev_addr, "FAKELL",
					card->dev->addr_len);
				netif_receive_skb(skb);
			} else {
				is_vlan = qeth_l3_rebuild_skb(card, skb, hdr,
1779
						      &vlan_tag);
1780 1781
				len = skb->len;
				if (is_vlan && !card->options.sniffer)
1782 1783
					__vlan_hwaccel_put_tag(skb,
						htons(ETH_P_8021Q), vlan_tag);
1784 1785
				napi_gro_receive(&card->napi, skb);
			}
1786
			break;
1787 1788 1789 1790 1791 1792
		case QETH_HEADER_TYPE_LAYER2: /* for HiperSockets sniffer */
			skb->pkt_type = PACKET_HOST;
			skb->protocol = eth_type_trans(skb, skb->dev);
			len = skb->len;
			netif_receive_skb(skb);
			break;
1793 1794
		default:
			dev_kfree_skb_any(skb);
1795
			QETH_CARD_TEXT(card, 3, "inbunkno");
1796
			QETH_DBF_HEX(CTRL, 3, hdr, QETH_DBF_CTRL_LEN);
1797 1798
			continue;
		}
1799 1800
		work_done++;
		budget--;
1801 1802 1803
		card->stats.rx_packets++;
		card->stats.rx_bytes += len;
	}
1804 1805 1806
	return work_done;
}

1807 1808 1809 1810
static int qeth_l3_verify_vlan_dev(struct net_device *dev,
			struct qeth_card *card)
{
	int rc = 0;
J
Jiri Pirko 已提交
1811
	u16 vid;
1812

J
Jiri Pirko 已提交
1813 1814
	for_each_set_bit(vid, card->active_vlans, VLAN_N_VID) {
		struct net_device *netdev;
1815

J
Jiri Pirko 已提交
1816
		rcu_read_lock();
1817
		netdev = __vlan_find_dev_deep_rcu(card->dev, htons(ETH_P_8021Q),
1818
					      vid);
J
Jiri Pirko 已提交
1819 1820
		rcu_read_unlock();
		if (netdev == dev) {
1821 1822 1823 1824 1825
			rc = QETH_VLAN_CARD;
			break;
		}
	}

1826
	if (rc && !(vlan_dev_real_dev(dev)->ml_priv == (void *)card))
1827 1828 1829 1830 1831 1832 1833 1834 1835
		return 0;

	return rc;
}

static int qeth_l3_verify_dev(struct net_device *dev)
{
	struct qeth_card *card;
	int rc = 0;
1836
	unsigned long flags;
1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859

	read_lock_irqsave(&qeth_core_card_list.rwlock, flags);
	list_for_each_entry(card, &qeth_core_card_list.list, list) {
		if (card->dev == dev) {
			rc = QETH_REAL_CARD;
			break;
		}
		rc = qeth_l3_verify_vlan_dev(dev, card);
		if (rc)
			break;
	}
	read_unlock_irqrestore(&qeth_core_card_list.rwlock, flags);

	return rc;
}

static struct qeth_card *qeth_l3_get_card_from_dev(struct net_device *dev)
{
	struct qeth_card *card = NULL;
	int rc;

	rc = qeth_l3_verify_dev(dev);
	if (rc == QETH_REAL_CARD)
1860
		card = dev->ml_priv;
1861
	else if (rc == QETH_VLAN_CARD)
1862
		card = vlan_dev_real_dev(dev)->ml_priv;
1863
	if (card && card->options.layer2)
1864
		card = NULL;
1865 1866
	if (card)
		QETH_CARD_TEXT_(card, 4, "%d", rc);
1867 1868 1869
	return card ;
}

1870
static void qeth_l3_stop_card(struct qeth_card *card, int recovery_mode)
1871
{
1872 1873
	QETH_DBF_TEXT(SETUP, 2, "stopcard");
	QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
1874 1875

	qeth_set_allowed_threads(card, 0, 1);
1876 1877 1878
	if (card->options.sniffer &&
	    (card->info.promisc_mode == SET_PROMISC_MODE_ON))
		qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_DISABLE);
1879 1880 1881 1882 1883
	if (card->read.state == CH_STATE_UP &&
	    card->write.state == CH_STATE_UP &&
	    (card->state == CARD_STATE_UP)) {
		if (recovery_mode)
			qeth_l3_stop(card->dev);
1884
		else {
1885 1886 1887
			rtnl_lock();
			dev_close(card->dev);
			rtnl_unlock();
1888
		}
1889 1890 1891
		card->state = CARD_STATE_SOFTSETUP;
	}
	if (card->state == CARD_STATE_SOFTSETUP) {
1892
		qeth_l3_clear_ip_htable(card, 1);
1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907
		qeth_clear_ipacmd_list(card);
		card->state = CARD_STATE_HARDSETUP;
	}
	if (card->state == CARD_STATE_HARDSETUP) {
		qeth_qdio_clear_card(card, 0);
		qeth_clear_qdio_buffers(card);
		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);
	}
}

1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928
/*
 * test for and Switch promiscuous mode (on or off)
 *  either for guestlan or HiperSocket Sniffer
 */
static void
qeth_l3_handle_promisc_mode(struct qeth_card *card)
{
	struct net_device *dev = card->dev;

	if (((dev->flags & IFF_PROMISC) &&
	     (card->info.promisc_mode == SET_PROMISC_MODE_ON)) ||
	    (!(dev->flags & IFF_PROMISC) &&
	     (card->info.promisc_mode == SET_PROMISC_MODE_OFF)))
		return;

	if (card->info.guestlan) {		/* Guestlan trace */
		if (qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE))
			qeth_setadp_promisc_mode(card);
	} else if (card->options.sniffer &&	/* HiperSockets trace */
		   qeth_adp_supported(card, IPA_SETADP_SET_DIAG_ASSIST)) {
		if (dev->flags & IFF_PROMISC) {
1929
			QETH_CARD_TEXT(card, 3, "+promisc");
1930 1931
			qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_ENABLE);
		} else {
1932
			QETH_CARD_TEXT(card, 3, "-promisc");
1933 1934 1935 1936 1937
			qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_DISABLE);
		}
	}
}

1938 1939
static void qeth_l3_set_multicast_list(struct net_device *dev)
{
1940
	struct qeth_card *card = dev->ml_priv;
1941

1942
	QETH_CARD_TEXT(card, 3, "setmulti");
1943 1944 1945
	if (qeth_threads_running(card, QETH_RECOVER_THREAD) &&
	    (card->state != CARD_STATE_UP))
		return;
1946
	if (!card->options.sniffer) {
1947 1948 1949 1950 1951

		spin_lock_bh(&card->mclock);

		qeth_l3_mark_all_mc_to_be_deleted(card);

1952
		qeth_l3_add_multicast_ipv4(card);
1953
#ifdef CONFIG_QETH_IPV6
1954
		qeth_l3_add_multicast_ipv6(card);
1955
#endif
1956 1957 1958 1959 1960
		qeth_l3_delete_nonused_mc(card);
		qeth_l3_add_all_new_mc(card);

		spin_unlock_bh(&card->mclock);

1961 1962 1963 1964
		if (!qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE))
			return;
	}
	qeth_l3_handle_promisc_mode(card);
1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994
}

static const char *qeth_l3_arp_get_error_cause(int *rc)
{
	switch (*rc) {
	case QETH_IPA_ARP_RC_FAILED:
		*rc = -EIO;
		return "operation failed";
	case QETH_IPA_ARP_RC_NOTSUPP:
		*rc = -EOPNOTSUPP;
		return "operation not supported";
	case QETH_IPA_ARP_RC_OUT_OF_RANGE:
		*rc = -EINVAL;
		return "argument out of range";
	case QETH_IPA_ARP_RC_Q_NOTSUPP:
		*rc = -EOPNOTSUPP;
		return "query operation not supported";
	case QETH_IPA_ARP_RC_Q_NO_DATA:
		*rc = -ENOENT;
		return "no query data available";
	default:
		return "unknown error";
	}
}

static int qeth_l3_arp_set_no_entries(struct qeth_card *card, int no_entries)
{
	int tmp;
	int rc;

1995
	QETH_CARD_TEXT(card, 3, "arpstnoe");
1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006

	/*
	 * currently GuestLAN only supports the ARP assist function
	 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_SET_NO_ENTRIES;
	 * thus we say EOPNOTSUPP for this ARP function
	 */
	if (card->info.guestlan)
		return -EOPNOTSUPP;
	if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
		return -EOPNOTSUPP;
	}
2007
	rc = qeth_send_simple_setassparms(card, IPA_ARP_PROCESSING,
2008 2009 2010 2011
					  IPA_CMD_ASS_ARP_SET_NO_ENTRIES,
					  no_entries);
	if (rc) {
		tmp = rc;
2012 2013
		QETH_DBF_MESSAGE(2, "Could not set number of ARP entries on "
			"%s: %s (0x%x/%d)\n", QETH_CARD_IFNAME(card),
2014 2015 2016 2017 2018
			qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
	}
	return rc;
}

2019 2020 2021
static __u32 get_arp_entry_size(struct qeth_card *card,
			struct qeth_arp_query_data *qdata,
			struct qeth_arp_entrytype *type, __u8 strip_entries)
2022
{
2023 2024
	__u32 rc;
	__u8 is_hsi;
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
	is_hsi = qdata->reply_bits == 5;
	if (type->ip == QETHARP_IP_ADDR_V4) {
		QETH_CARD_TEXT(card, 4, "arpev4");
		if (strip_entries) {
			rc = is_hsi ? sizeof(struct qeth_arp_qi_entry5_short) :
				sizeof(struct qeth_arp_qi_entry7_short);
		} else {
			rc = is_hsi ? sizeof(struct qeth_arp_qi_entry5) :
				sizeof(struct qeth_arp_qi_entry7);
		}
	} else if (type->ip == QETHARP_IP_ADDR_V6) {
		QETH_CARD_TEXT(card, 4, "arpev6");
		if (strip_entries) {
			rc = is_hsi ?
				sizeof(struct qeth_arp_qi_entry5_short_ipv6) :
				sizeof(struct qeth_arp_qi_entry7_short_ipv6);
		} else {
			rc = is_hsi ?
				sizeof(struct qeth_arp_qi_entry5_ipv6) :
				sizeof(struct qeth_arp_qi_entry7_ipv6);
		}
	} else {
		QETH_CARD_TEXT(card, 4, "arpinv");
		rc = 0;
2050
	}
2051 2052 2053 2054 2055 2056 2057 2058

	return rc;
}

static int arpentry_matches_prot(struct qeth_arp_entrytype *type, __u16 prot)
{
	return (type->ip == QETHARP_IP_ADDR_V4 && prot == QETH_PROT_IPV4) ||
		(type->ip == QETHARP_IP_ADDR_V6 && prot == QETH_PROT_IPV6);
2059 2060 2061 2062 2063 2064 2065 2066 2067
}

static int qeth_l3_arp_query_cb(struct qeth_card *card,
		struct qeth_reply *reply, unsigned long data)
{
	struct qeth_ipa_cmd *cmd;
	struct qeth_arp_query_data *qdata;
	struct qeth_arp_query_info *qinfo;
	int i;
2068 2069 2070 2071
	int e;
	int entrybytes_done;
	int stripped_bytes;
	__u8 do_strip_entries;
2072

2073
	QETH_CARD_TEXT(card, 3, "arpquecb");
2074 2075 2076

	qinfo = (struct qeth_arp_query_info *) reply->param;
	cmd = (struct qeth_ipa_cmd *) data;
2077
	QETH_CARD_TEXT_(card, 4, "%i", cmd->hdr.prot_version);
2078
	if (cmd->hdr.return_code) {
2079 2080
		QETH_CARD_TEXT(card, 4, "arpcberr");
		QETH_CARD_TEXT_(card, 4, "%i", cmd->hdr.return_code);
2081 2082 2083 2084
		return 0;
	}
	if (cmd->data.setassparms.hdr.return_code) {
		cmd->hdr.return_code = cmd->data.setassparms.hdr.return_code;
2085 2086
		QETH_CARD_TEXT(card, 4, "setaperr");
		QETH_CARD_TEXT_(card, 4, "%i", cmd->hdr.return_code);
2087 2088 2089
		return 0;
	}
	qdata = &cmd->data.setassparms.data.query_arp;
2090
	QETH_CARD_TEXT_(card, 4, "anoen%i", qdata->no_entries);
2091

2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114
	do_strip_entries = (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES) > 0;
	stripped_bytes = do_strip_entries ? QETH_QARP_MEDIASPECIFIC_BYTES : 0;
	entrybytes_done = 0;
	for (e = 0; e < qdata->no_entries; ++e) {
		char *cur_entry;
		__u32 esize;
		struct qeth_arp_entrytype *etype;

		cur_entry = &qdata->data + entrybytes_done;
		etype = &((struct qeth_arp_qi_entry5 *) cur_entry)->type;
		if (!arpentry_matches_prot(etype, cmd->hdr.prot_version)) {
			QETH_CARD_TEXT(card, 4, "pmis");
			QETH_CARD_TEXT_(card, 4, "%i", etype->ip);
			break;
		}
		esize = get_arp_entry_size(card, qdata, etype,
			do_strip_entries);
		QETH_CARD_TEXT_(card, 5, "esz%i", esize);
		if (!esize)
			break;

		if ((qinfo->udata_len - qinfo->udata_offset) < esize) {
			QETH_CARD_TEXT_(card, 4, "qaer3%i", -ENOMEM);
2115
			cmd->hdr.return_code = IPA_RC_ENOMEM;
2116 2117
			goto out_error;
		}
2118

2119 2120 2121 2122 2123 2124 2125
		memcpy(qinfo->udata + qinfo->udata_offset,
			&qdata->data + entrybytes_done + stripped_bytes,
			esize);
		entrybytes_done += esize + stripped_bytes;
		qinfo->udata_offset += esize;
		++qinfo->no_entries;
	}
2126 2127 2128 2129
	/* check if all replies received ... */
	if (cmd->data.setassparms.hdr.seq_no <
	    cmd->data.setassparms.hdr.number_of_replies)
		return 1;
2130
	QETH_CARD_TEXT_(card, 4, "nove%i", qinfo->no_entries);
2131 2132 2133 2134 2135 2136
	memcpy(qinfo->udata, &qinfo->no_entries, 4);
	/* keep STRIP_ENTRIES flag so the user program can distinguish
	 * stripped entries from normal ones */
	if (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES)
		qdata->reply_bits |= QETH_QARP_STRIP_ENTRIES;
	memcpy(qinfo->udata + QETH_QARP_MASK_OFFSET, &qdata->reply_bits, 2);
2137
	QETH_CARD_TEXT_(card, 4, "rc%i", 0);
2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150
	return 0;
out_error:
	i = 0;
	memcpy(qinfo->udata, &i, 4);
	return 0;
}

static int qeth_l3_send_ipa_arp_cmd(struct qeth_card *card,
		struct qeth_cmd_buffer *iob, int len,
		int (*reply_cb)(struct qeth_card *, struct qeth_reply *,
			unsigned long),
		void *reply_param)
{
2151
	QETH_CARD_TEXT(card, 4, "sendarp");
2152 2153 2154 2155 2156 2157 2158 2159

	memcpy(iob->data, IPA_PDU_HEADER, IPA_PDU_HEADER_SIZE);
	memcpy(QETH_IPA_CMD_DEST_ADDR(iob->data),
	       &card->token.ulp_connection_r, QETH_MPC_TOKEN_LENGTH);
	return qeth_send_control_data(card, IPA_PDU_HEADER_SIZE + len, iob,
				      reply_cb, reply_param);
}

2160 2161 2162
static int qeth_l3_query_arp_cache_info(struct qeth_card *card,
	enum qeth_prot_versions prot,
	struct qeth_arp_query_info *qinfo)
2163 2164
{
	struct qeth_cmd_buffer *iob;
2165
	struct qeth_ipa_cmd *cmd;
2166 2167 2168
	int tmp;
	int rc;

2169 2170
	QETH_CARD_TEXT_(card, 3, "qarpipv%i", prot);

2171 2172 2173 2174 2175
	iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
				       IPA_CMD_ASS_ARP_QUERY_INFO,
				       sizeof(struct qeth_arp_query_data)
						- sizeof(char),
				       prot);
2176 2177
	if (!iob)
		return -ENOMEM;
2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200
	cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
	cmd->data.setassparms.data.query_arp.request_bits = 0x000F;
	cmd->data.setassparms.data.query_arp.reply_bits = 0;
	cmd->data.setassparms.data.query_arp.no_entries = 0;
	rc = qeth_l3_send_ipa_arp_cmd(card, iob,
			   QETH_SETASS_BASE_LEN+QETH_ARP_CMD_LEN,
			   qeth_l3_arp_query_cb, (void *)qinfo);
	if (rc) {
		tmp = rc;
		QETH_DBF_MESSAGE(2,
			"Error while querying ARP cache on %s: %s "
			"(0x%x/%d)\n", QETH_CARD_IFNAME(card),
			qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
	}

	return rc;
}

static int qeth_l3_arp_query(struct qeth_card *card, char __user *udata)
{
	struct qeth_arp_query_info qinfo = {0, };
	int rc;

2201
	QETH_CARD_TEXT(card, 3, "arpquery");
2202 2203 2204

	if (!qeth_is_supported(card,/*IPA_QUERY_ARP_ADDR_INFO*/
			       IPA_ARP_PROCESSING)) {
2205 2206 2207
		QETH_CARD_TEXT(card, 3, "arpqnsup");
		rc = -EOPNOTSUPP;
		goto out;
2208 2209
	}
	/* get size of userspace buffer and mask_bits -> 6 bytes */
2210 2211 2212 2213
	if (copy_from_user(&qinfo, udata, 6)) {
		rc = -EFAULT;
		goto out;
	}
2214
	qinfo.udata = kzalloc(qinfo.udata_len, GFP_KERNEL);
2215 2216 2217 2218
	if (!qinfo.udata) {
		rc = -ENOMEM;
		goto out;
	}
2219
	qinfo.udata_offset = QETH_QARP_ENTRIES_OFFSET;
2220
	rc = qeth_l3_query_arp_cache_info(card, QETH_PROT_IPV4, &qinfo);
2221 2222 2223
	if (rc) {
		if (copy_to_user(udata, qinfo.udata, 4))
			rc = -EFAULT;
2224 2225
		goto free_and_out;
	}
2226
#ifdef CONFIG_QETH_IPV6
2227 2228 2229 2230
	if (qinfo.mask_bits & QETH_QARP_WITH_IPV6) {
		/* fails in case of GuestLAN QDIO mode */
		qeth_l3_query_arp_cache_info(card, QETH_PROT_IPV6, &qinfo);
	}
2231
#endif
2232 2233 2234 2235
	if (copy_to_user(udata, qinfo.udata, qinfo.udata_len)) {
		QETH_CARD_TEXT(card, 4, "qactf");
		rc = -EFAULT;
		goto free_and_out;
2236
	}
2237 2238
	QETH_CARD_TEXT(card, 4, "qacts");

2239
free_and_out:
2240
	kfree(qinfo.udata);
2241
out:
2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252
	return rc;
}

static int qeth_l3_arp_add_entry(struct qeth_card *card,
				struct qeth_arp_cache_entry *entry)
{
	struct qeth_cmd_buffer *iob;
	char buf[16];
	int tmp;
	int rc;

2253
	QETH_CARD_TEXT(card, 3, "arpadent");
2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265

	/*
	 * currently GuestLAN only supports the ARP assist function
	 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_ADD_ENTRY;
	 * thus we say EOPNOTSUPP for this ARP function
	 */
	if (card->info.guestlan)
		return -EOPNOTSUPP;
	if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
		return -EOPNOTSUPP;
	}

2266
	iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
2267 2268 2269
				       IPA_CMD_ASS_ARP_ADD_ENTRY,
				       sizeof(struct qeth_arp_cache_entry),
				       QETH_PROT_IPV4);
2270 2271
	if (!iob)
		return -ENOMEM;
2272
	rc = qeth_send_setassparms(card, iob,
2273 2274
				   sizeof(struct qeth_arp_cache_entry),
				   (unsigned long) entry,
2275
				   qeth_setassparms_cb, NULL);
2276 2277 2278
	if (rc) {
		tmp = rc;
		qeth_l3_ipaddr4_to_string((u8 *)entry->ipaddr, buf);
2279 2280 2281
		QETH_DBF_MESSAGE(2, "Could not add ARP entry for address %s "
			"on %s: %s (0x%x/%d)\n", buf, QETH_CARD_IFNAME(card),
			qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293
	}
	return rc;
}

static int qeth_l3_arp_remove_entry(struct qeth_card *card,
				struct qeth_arp_cache_entry *entry)
{
	struct qeth_cmd_buffer *iob;
	char buf[16] = {0, };
	int tmp;
	int rc;

2294
	QETH_CARD_TEXT(card, 3, "arprment");
2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306

	/*
	 * currently GuestLAN only supports the ARP assist function
	 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_REMOVE_ENTRY;
	 * thus we say EOPNOTSUPP for this ARP function
	 */
	if (card->info.guestlan)
		return -EOPNOTSUPP;
	if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
		return -EOPNOTSUPP;
	}
	memcpy(buf, entry, 12);
2307
	iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
2308 2309 2310
				       IPA_CMD_ASS_ARP_REMOVE_ENTRY,
				       12,
				       QETH_PROT_IPV4);
2311 2312
	if (!iob)
		return -ENOMEM;
2313
	rc = qeth_send_setassparms(card, iob,
2314
				   12, (unsigned long)buf,
2315
				   qeth_setassparms_cb, NULL);
2316 2317 2318 2319
	if (rc) {
		tmp = rc;
		memset(buf, 0, 16);
		qeth_l3_ipaddr4_to_string((u8 *)entry->ipaddr, buf);
2320 2321 2322
		QETH_DBF_MESSAGE(2, "Could not delete ARP entry for address %s"
			" on %s: %s (0x%x/%d)\n", buf, QETH_CARD_IFNAME(card),
			qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
2323 2324 2325 2326 2327 2328 2329 2330 2331
	}
	return rc;
}

static int qeth_l3_arp_flush_cache(struct qeth_card *card)
{
	int rc;
	int tmp;

2332
	QETH_CARD_TEXT(card, 3, "arpflush");
2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343

	/*
	 * currently GuestLAN only supports the ARP assist function
	 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_FLUSH_CACHE;
	 * thus we say EOPNOTSUPP for this ARP function
	*/
	if (card->info.guestlan || (card->info.type == QETH_CARD_TYPE_IQD))
		return -EOPNOTSUPP;
	if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
		return -EOPNOTSUPP;
	}
2344
	rc = qeth_send_simple_setassparms(card, IPA_ARP_PROCESSING,
2345 2346 2347
					  IPA_CMD_ASS_ARP_FLUSH_CACHE, 0);
	if (rc) {
		tmp = rc;
2348 2349
		QETH_DBF_MESSAGE(2, "Could not flush ARP cache on %s: %s "
			"(0x%x/%d)\n", QETH_CARD_IFNAME(card),
2350 2351 2352 2353 2354 2355 2356
			qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
	}
	return rc;
}

static int qeth_l3_do_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
{
2357
	struct qeth_card *card = dev->ml_priv;
2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410
	struct qeth_arp_cache_entry arp_entry;
	int rc = 0;

	switch (cmd) {
	case SIOC_QETH_ARP_SET_NO_ENTRIES:
		if (!capable(CAP_NET_ADMIN)) {
			rc = -EPERM;
			break;
		}
		rc = qeth_l3_arp_set_no_entries(card, rq->ifr_ifru.ifru_ivalue);
		break;
	case SIOC_QETH_ARP_QUERY_INFO:
		if (!capable(CAP_NET_ADMIN)) {
			rc = -EPERM;
			break;
		}
		rc = qeth_l3_arp_query(card, rq->ifr_ifru.ifru_data);
		break;
	case SIOC_QETH_ARP_ADD_ENTRY:
		if (!capable(CAP_NET_ADMIN)) {
			rc = -EPERM;
			break;
		}
		if (copy_from_user(&arp_entry, rq->ifr_ifru.ifru_data,
				   sizeof(struct qeth_arp_cache_entry)))
			rc = -EFAULT;
		else
			rc = qeth_l3_arp_add_entry(card, &arp_entry);
		break;
	case SIOC_QETH_ARP_REMOVE_ENTRY:
		if (!capable(CAP_NET_ADMIN)) {
			rc = -EPERM;
			break;
		}
		if (copy_from_user(&arp_entry, rq->ifr_ifru.ifru_data,
				   sizeof(struct qeth_arp_cache_entry)))
			rc = -EFAULT;
		else
			rc = qeth_l3_arp_remove_entry(card, &arp_entry);
		break;
	case SIOC_QETH_ARP_FLUSH_CACHE:
		if (!capable(CAP_NET_ADMIN)) {
			rc = -EPERM;
			break;
		}
		rc = qeth_l3_arp_flush_cache(card);
		break;
	default:
		rc = -EOPNOTSUPP;
	}
	return rc;
}

2411 2412 2413
int inline qeth_l3_get_cast_type(struct qeth_card *card, struct sk_buff *skb)
{
	int cast_type = RTN_UNSPEC;
2414 2415 2416
	struct neighbour *n = NULL;
	struct dst_entry *dst;

2417
	rcu_read_lock();
2418 2419
	dst = skb_dst(skb);
	if (dst)
2420
		n = dst_neigh_lookup_skb(dst, skb);
2421 2422
	if (n) {
		cast_type = n->type;
2423
		rcu_read_unlock();
2424
		neigh_release(n);
2425 2426 2427 2428 2429 2430 2431
		if ((cast_type == RTN_BROADCAST) ||
		    (cast_type == RTN_MULTICAST) ||
		    (cast_type == RTN_ANYCAST))
			return cast_type;
		else
			return RTN_UNSPEC;
	}
2432 2433
	rcu_read_unlock();

2434
	/* try something else */
2435
	if (be16_to_cpu(skb->protocol) == ETH_P_IPV6)
2436 2437
		return (skb_network_header(skb)[24] == 0xff) ?
				RTN_MULTICAST : 0;
2438
	else if (be16_to_cpu(skb->protocol) == ETH_P_IP)
2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465
		return ((skb_network_header(skb)[16] & 0xf0) == 0xe0) ?
				RTN_MULTICAST : 0;
	/* ... */
	if (!memcmp(skb->data, skb->dev->broadcast, 6))
		return RTN_BROADCAST;
	else {
		u16 hdr_mac;

		hdr_mac = *((u16 *)skb->data);
		/* tr multicast? */
		switch (card->info.link_type) {
		case QETH_LINK_TYPE_HSTR:
		case QETH_LINK_TYPE_LANE_TR:
			if ((hdr_mac == QETH_TR_MAC_NC) ||
			    (hdr_mac == QETH_TR_MAC_C))
				return RTN_MULTICAST;
			break;
		/* eth or so multicast? */
		default:
		if ((hdr_mac == QETH_ETH_MAC_V4) ||
			    (hdr_mac == QETH_ETH_MAC_V6))
				return RTN_MULTICAST;
		}
	}
	return cast_type;
}

2466 2467 2468 2469 2470 2471 2472 2473 2474
static void qeth_l3_fill_af_iucv_hdr(struct qeth_card *card,
		struct qeth_hdr *hdr, struct sk_buff *skb)
{
	char daddr[16];
	struct af_iucv_trans_hdr *iucv_hdr;

	memset(hdr, 0, sizeof(struct qeth_hdr));
	hdr->hdr.l3.id = QETH_HEADER_TYPE_LAYER3;
	hdr->hdr.l3.ext_flags = 0;
2475
	hdr->hdr.l3.length = skb->len - ETH_HLEN;
2476
	hdr->hdr.l3.flags = QETH_HDR_IPV6 | QETH_CAST_UNICAST;
2477 2478

	iucv_hdr = (struct af_iucv_trans_hdr *) (skb->data + ETH_HLEN);
2479 2480 2481 2482 2483 2484 2485
	memset(daddr, 0, sizeof(daddr));
	daddr[0] = 0xfe;
	daddr[1] = 0x80;
	memcpy(&daddr[8], iucv_hdr->destUserID, 8);
	memcpy(hdr->hdr.l3.dest_addr, daddr, 16);
}

2486 2487 2488
static void qeth_l3_fill_header(struct qeth_card *card, struct qeth_hdr *hdr,
		struct sk_buff *skb, int ipv, int cast_type)
{
2489 2490
	struct dst_entry *dst;

2491 2492 2493 2494 2495 2496 2497 2498
	memset(hdr, 0, sizeof(struct qeth_hdr));
	hdr->hdr.l3.id = QETH_HEADER_TYPE_LAYER3;
	hdr->hdr.l3.ext_flags = 0;

	/*
	 * before we're going to overwrite this location with next hop ip.
	 * v6 uses passthrough, v4 sets the tag in the QDIO header.
	 */
2499
	if (skb_vlan_tag_present(skb)) {
2500 2501 2502 2503
		if ((ipv == 4) || (card->info.type == QETH_CARD_TYPE_IQD))
			hdr->hdr.l3.ext_flags = QETH_HDR_EXT_VLAN_FRAME;
		else
			hdr->hdr.l3.ext_flags = QETH_HDR_EXT_INCLUDE_VLAN_TAG;
2504
		hdr->hdr.l3.vlan_id = skb_vlan_tag_get(skb);
2505 2506 2507
	}

	hdr->hdr.l3.length = skb->len - sizeof(struct qeth_hdr);
2508 2509

	rcu_read_lock();
2510
	dst = skb_dst(skb);
2511
	if (ipv == 4) {
2512 2513 2514 2515 2516 2517
		struct rtable *rt = (struct rtable *) dst;
		__be32 *pkey = &ip_hdr(skb)->daddr;

		if (rt->rt_gateway)
			pkey = &rt->rt_gateway;

2518 2519 2520
		/* IPv4 */
		hdr->hdr.l3.flags = qeth_l3_get_qeth_hdr_flags4(cast_type);
		memset(hdr->hdr.l3.dest_addr, 0, 12);
2521
		*((__be32 *) (&hdr->hdr.l3.dest_addr[12])) = *pkey;
2522
	} else if (ipv == 6) {
2523 2524 2525 2526 2527 2528
		struct rt6_info *rt = (struct rt6_info *) dst;
		struct in6_addr *pkey = &ipv6_hdr(skb)->daddr;

		if (!ipv6_addr_any(&rt->rt6i_gateway))
			pkey = &rt->rt6i_gateway;

2529 2530 2531 2532
		/* IPv6 */
		hdr->hdr.l3.flags = qeth_l3_get_qeth_hdr_flags6(cast_type);
		if (card->info.type == QETH_CARD_TYPE_IQD)
			hdr->hdr.l3.flags &= ~QETH_HDR_PASSTHRU;
2533
		memcpy(hdr->hdr.l3.dest_addr, pkey, 16);
2534
	} else {
2535
		if (!memcmp(skb->data + sizeof(struct qeth_hdr),
2536 2537 2538 2539 2540 2541 2542 2543 2544 2545
			    skb->dev->broadcast, 6)) {
			/* broadcast? */
			hdr->hdr.l3.flags = QETH_CAST_BROADCAST |
						QETH_HDR_PASSTHRU;
		} else {
			hdr->hdr.l3.flags = (cast_type == RTN_MULTICAST) ?
				QETH_CAST_MULTICAST | QETH_HDR_PASSTHRU :
				QETH_CAST_UNICAST | QETH_HDR_PASSTHRU;
		}
	}
2546
	rcu_read_unlock();
2547 2548
}

2549 2550 2551 2552 2553 2554 2555 2556 2557 2558
static inline void qeth_l3_hdr_csum(struct qeth_card *card,
		struct qeth_hdr *hdr, struct sk_buff *skb)
{
	struct iphdr *iph = ip_hdr(skb);

	/* tcph->check contains already the pseudo hdr checksum
	 * so just set the header flags
	 */
	if (iph->protocol == IPPROTO_UDP)
		hdr->hdr.l3.ext_flags |= QETH_HDR_EXT_UDP;
2559 2560 2561
	hdr->hdr.l3.ext_flags |= QETH_HDR_EXT_CSUM_TRANSP_REQ |
		QETH_HDR_EXT_CSUM_HDR_REQ;
	iph->check = 0;
2562 2563 2564 2565
	if (card->options.performance_stats)
		card->perf_stats.tx_csum++;
}

F
Frank Blaschka 已提交
2566 2567 2568 2569 2570 2571 2572 2573 2574 2575
static void qeth_tso_fill_header(struct qeth_card *card,
		struct qeth_hdr *qhdr, struct sk_buff *skb)
{
	struct qeth_hdr_tso *hdr = (struct qeth_hdr_tso *)qhdr;
	struct tcphdr *tcph = tcp_hdr(skb);
	struct iphdr *iph = ip_hdr(skb);
	struct ipv6hdr *ip6h = ipv6_hdr(skb);

	/*fix header to TSO values ...*/
	hdr->hdr.hdr.l3.id = QETH_HEADER_TYPE_TSO;
2576
	hdr->hdr.hdr.l3.length = skb->len - sizeof(struct qeth_hdr_tso);
F
Frank Blaschka 已提交
2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588
	/*set values which are fix for the first approach ...*/
	hdr->ext.hdr_tot_len = (__u16) sizeof(struct qeth_hdr_ext_tso);
	hdr->ext.imb_hdr_no  = 1;
	hdr->ext.hdr_type    = 1;
	hdr->ext.hdr_version = 1;
	hdr->ext.hdr_len     = 28;
	/*insert non-fix values */
	hdr->ext.mss = skb_shinfo(skb)->gso_size;
	hdr->ext.dg_hdr_len = (__u16)(iph->ihl*4 + tcph->doff*4);
	hdr->ext.payload_len = (__u16)(skb->len - hdr->ext.dg_hdr_len -
				       sizeof(struct qeth_hdr_tso));
	tcph->check = 0;
2589
	if (be16_to_cpu(skb->protocol) == ETH_P_IPV6) {
F
Frank Blaschka 已提交
2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601
		ip6h->payload_len = 0;
		tcph->check = ~csum_ipv6_magic(&ip6h->saddr, &ip6h->daddr,
					       0, IPPROTO_TCP, 0);
	} else {
		/*OSA want us to set these values ...*/
		tcph->check = ~csum_tcpudp_magic(iph->saddr, iph->daddr,
					 0, IPPROTO_TCP, 0);
		iph->tot_len = 0;
		iph->check = 0;
	}
}

2602
/**
2603 2604 2605 2606
 * qeth_l3_get_elements_no_tso() - find number of SBALEs for skb data for tso
 * @card:			   qeth card structure, to check max. elems.
 * @skb:			   SKB address
 * @extra_elems:		   extra elems needed, to check against max.
2607 2608 2609 2610 2611 2612 2613 2614
 *
 * Returns the number of pages, and thus QDIO buffer elements, needed to cover
 * skb data, including linear part and fragments, but excluding TCP header.
 * (Exclusion of TCP header distinguishes it from qeth_get_elements_no().)
 * Checks if the result plus extra_elems fits under the limit for the card.
 * Returns 0 if it does not.
 * Note: extra_elems is not included in the returned result.
 */
2615
static int qeth_l3_get_elements_no_tso(struct qeth_card *card,
2616
			struct sk_buff *skb, int extra_elems)
2617
{
2618 2619 2620 2621
	addr_t tcpdptr = (addr_t)tcp_hdr(skb) + tcp_hdrlen(skb);
	int elements = qeth_get_elements_for_range(
				tcpdptr,
				(addr_t)skb->data + skb_headlen(skb)) +
2622
				qeth_get_elements_for_frags(skb);
2623

2624 2625 2626 2627 2628 2629
	if ((elements + extra_elems) > QETH_MAX_BUFFER_ELEMENTS(card)) {
		QETH_DBF_MESSAGE(2,
	"Invalid size of TSO IP packet (Number=%d / Length=%d). Discarded.\n",
				elements + extra_elems, skb->len);
		return 0;
	}
2630 2631 2632
	return elements;
}

2633 2634
static netdev_tx_t qeth_l3_hard_start_xmit(struct sk_buff *skb,
					   struct net_device *dev)
2635 2636
{
	int rc;
2637
	__be16 *tag;
2638
	struct qeth_hdr *hdr = NULL;
2639 2640
	int hdr_elements = 0;
	int elements;
2641
	struct qeth_card *card = dev->ml_priv;
2642 2643
	struct sk_buff *new_skb = NULL;
	int ipv = qeth_get_ip_version(skb);
2644
	int cast_type = qeth_l3_get_cast_type(card, skb);
2645 2646 2647 2648 2649
	struct qeth_qdio_out_q *queue =
		card->qdio.out_qs[card->qdio.do_prio_queueing
			|| (cast_type && card->info.is_multicast_different) ?
			qeth_get_priority_queue(card, skb, ipv, cast_type) :
			card->qdio.default_out_queue];
2650
	int tx_bytes = skb->len;
2651
	bool use_tso;
2652
	int data_offset = -1;
F
Frank Blaschka 已提交
2653
	int nr_frags;
2654

2655 2656 2657
	if (((card->info.type == QETH_CARD_TYPE_IQD) &&
	     (((card->options.cq != QETH_CQ_ENABLED) && !ipv) ||
	      ((card->options.cq == QETH_CQ_ENABLED) &&
2658
	       (be16_to_cpu(skb->protocol) != ETH_P_AF_IUCV)))) ||
2659
	    card->options.sniffer)
2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675
			goto tx_drop;

	if ((card->state != CARD_STATE_UP) || !card->lan_online) {
		card->stats.tx_carrier_errors++;
		goto tx_drop;
	}

	if ((cast_type == RTN_BROADCAST) &&
	    (card->info.broadcast_capable == 0))
		goto tx_drop;

	if (card->options.performance_stats) {
		card->perf_stats.outbound_cnt++;
		card->perf_stats.outbound_start_time = qeth_get_micros();
	}

2676 2677 2678
	/* Ignore segment size from skb_is_gso(), 1 page is always used. */
	use_tso = skb_is_gso(skb) &&
		  (qeth_get_ip_protocol(skb) == IPPROTO_TCP) && (ipv == 4);
2679

2680
	if (card->info.type == QETH_CARD_TYPE_IQD) {
2681
		new_skb = skb;
2682
		data_offset = ETH_HLEN;
2683 2684 2685
		hdr = kmem_cache_alloc(qeth_core_header_cache, GFP_ATOMIC);
		if (!hdr)
			goto tx_drop;
2686
		hdr_elements++;
2687 2688 2689 2690 2691 2692
	} else {
		/* create a clone with writeable headroom */
		new_skb = skb_realloc_headroom(skb, sizeof(struct qeth_hdr_tso)
					+ VLAN_HLEN);
		if (!new_skb)
			goto tx_drop;
2693

2694
		if (ipv == 4) {
2695
			skb_pull(new_skb, ETH_HLEN);
2696 2697
		}

2698
		if (ipv != 4 && skb_vlan_tag_present(new_skb)) {
2699 2700 2701 2702 2703 2704
			skb_push(new_skb, VLAN_HLEN);
			skb_copy_to_linear_data(new_skb, new_skb->data + 4, 4);
			skb_copy_to_linear_data_offset(new_skb, 4,
				new_skb->data + 8, 4);
			skb_copy_to_linear_data_offset(new_skb, 8,
				new_skb->data + 12, 4);
2705 2706 2707
			tag = (__be16 *)(new_skb->data + 12);
			*tag = cpu_to_be16(ETH_P_8021Q);
			*(tag + 1) = cpu_to_be16(skb_vlan_tag_get(new_skb));
2708 2709 2710 2711 2712 2713
		}
	}

	netif_stop_queue(dev);

	/* fix hardware limitation: as long as we do not have sbal
F
Frank Blaschka 已提交
2714
	 * chaining we can not send long frag lists
2715
	 */
2716 2717
	if ((card->info.type != QETH_CARD_TYPE_IQD) &&
	    ((use_tso && !qeth_l3_get_elements_no_tso(card, new_skb, 1)) ||
2718
	     (!use_tso && !qeth_get_elements_no(card, new_skb, 0, 0)))) {
2719 2720 2721 2722 2723 2724 2725 2726 2727
		int lin_rc = skb_linearize(new_skb);

		if (card->options.performance_stats) {
			if (lin_rc)
				card->perf_stats.tx_linfail++;
			else
				card->perf_stats.tx_lin++;
		}
		if (lin_rc)
2728
			goto tx_drop;
F
Frank Blaschka 已提交
2729
	}
2730

2731
	if (use_tso) {
2732
		hdr = skb_push(new_skb, sizeof(struct qeth_hdr_tso));
2733 2734 2735
		memset(hdr, 0, sizeof(struct qeth_hdr_tso));
		qeth_l3_fill_header(card, hdr, new_skb, ipv, cast_type);
		qeth_tso_fill_header(card, hdr, new_skb);
2736
		hdr_elements++;
2737
	} else {
2738
		if (data_offset < 0) {
2739
			hdr = skb_push(new_skb, sizeof(struct qeth_hdr));
2740 2741 2742
			qeth_l3_fill_header(card, hdr, new_skb, ipv,
						cast_type);
		} else {
2743
			if (be16_to_cpu(new_skb->protocol) == ETH_P_AF_IUCV)
2744 2745 2746 2747 2748 2749
				qeth_l3_fill_af_iucv_hdr(card, hdr, new_skb);
			else {
				qeth_l3_fill_header(card, hdr, new_skb, ipv,
							cast_type);
				hdr->hdr.l3.length = new_skb->len - data_offset;
			}
2750
		}
2751 2752 2753

		if (skb->ip_summed == CHECKSUM_PARTIAL)
			qeth_l3_hdr_csum(card, hdr, new_skb);
2754 2755
	}

2756 2757
	elements = use_tso ?
		   qeth_l3_get_elements_no_tso(card, new_skb, hdr_elements) :
2758 2759
		   qeth_get_elements_no(card, new_skb, hdr_elements,
					(data_offset > 0) ? data_offset : 0);
2760
	if (!elements) {
F
Frank Blaschka 已提交
2761 2762 2763
		if (data_offset >= 0)
			kmem_cache_free(qeth_core_header_cache, hdr);
		goto tx_drop;
2764
	}
2765
	elements += hdr_elements;
2766

2767 2768
	if (card->info.type != QETH_CARD_TYPE_IQD) {
		int len;
2769
		if (use_tso)
2770
			len = ((unsigned long)tcp_hdr(new_skb) +
2771
				tcp_hdrlen(new_skb)) -
2772 2773 2774 2775
				(unsigned long)new_skb->data;
		else
			len = sizeof(struct qeth_hdr_layer3);

2776
		if (qeth_hdr_chk_and_bounce(new_skb, &hdr, len))
2777
			goto tx_drop;
2778
		rc = qeth_do_send_packet(card, queue, new_skb, hdr, elements);
2779
	} else
2780
		rc = qeth_do_send_packet_fast(card, queue, new_skb, hdr,
2781
					      data_offset, 0);
2782 2783 2784 2785 2786 2787 2788

	if (!rc) {
		card->stats.tx_packets++;
		card->stats.tx_bytes += tx_bytes;
		if (new_skb != skb)
			dev_kfree_skb_any(skb);
		if (card->options.performance_stats) {
2789
			nr_frags = skb_shinfo(new_skb)->nr_frags;
2790
			if (use_tso) {
2791 2792 2793
				card->perf_stats.large_send_bytes += tx_bytes;
				card->perf_stats.large_send_cnt++;
			}
F
Frank Blaschka 已提交
2794
			if (nr_frags) {
2795 2796
				card->perf_stats.sg_skbs_sent++;
				/* nr_frags + skb->data */
F
Frank Blaschka 已提交
2797
				card->perf_stats.sg_frags_sent += nr_frags + 1;
2798 2799
			}
		}
2800
		rc = NETDEV_TX_OK;
2801
	} else {
2802 2803 2804
		if (data_offset >= 0)
			kmem_cache_free(qeth_core_header_cache, hdr);

2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824
		if (rc == -EBUSY) {
			if (new_skb != skb)
				dev_kfree_skb_any(new_skb);
			return NETDEV_TX_BUSY;
		} else
			goto tx_drop;
	}

	netif_wake_queue(dev);
	if (card->options.performance_stats)
		card->perf_stats.outbound_time += qeth_get_micros() -
			card->perf_stats.outbound_start_time;
	return rc;

tx_drop:
	card->stats.tx_dropped++;
	card->stats.tx_errors++;
	if ((new_skb != skb) && new_skb)
		dev_kfree_skb_any(new_skb);
	dev_kfree_skb_any(skb);
2825
	netif_wake_queue(dev);
2826 2827 2828
	return NETDEV_TX_OK;
}

2829
static int __qeth_l3_open(struct net_device *dev)
2830
{
2831
	struct qeth_card *card = dev->ml_priv;
2832
	int rc = 0;
2833

2834
	QETH_CARD_TEXT(card, 4, "qethopen");
2835 2836
	if (card->state == CARD_STATE_UP)
		return rc;
2837 2838 2839 2840 2841 2842
	if (card->state != CARD_STATE_SOFTSETUP)
		return -ENODEV;
	card->data.state = CH_STATE_UP;
	card->state = CARD_STATE_UP;
	netif_start_queue(dev);

2843 2844 2845 2846 2847 2848
	if (qdio_stop_irq(card->data.ccwdev, 0) >= 0) {
		napi_enable(&card->napi);
		napi_schedule(&card->napi);
	} else
		rc = -EIO;
	return rc;
2849 2850
}

2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862
static int qeth_l3_open(struct net_device *dev)
{
	struct qeth_card *card = dev->ml_priv;

	QETH_CARD_TEXT(card, 5, "qethope_");
	if (qeth_wait_for_threads(card, QETH_RECOVER_THREAD)) {
		QETH_CARD_TEXT(card, 3, "openREC");
		return -ERESTARTSYS;
	}
	return __qeth_l3_open(dev);
}

2863 2864
static int qeth_l3_stop(struct net_device *dev)
{
2865
	struct qeth_card *card = dev->ml_priv;
2866

2867
	QETH_CARD_TEXT(card, 4, "qethstop");
2868
	netif_tx_disable(dev);
2869
	if (card->state == CARD_STATE_UP) {
2870
		card->state = CARD_STATE_SOFTSETUP;
2871 2872
		napi_disable(&card->napi);
	}
2873 2874 2875
	return 0;
}

2876
static const struct ethtool_ops qeth_l3_ethtool_ops = {
2877 2878 2879
	.get_link = ethtool_op_get_link,
	.get_strings = qeth_core_get_strings,
	.get_ethtool_stats = qeth_core_get_ethtool_stats,
2880
	.get_sset_count = qeth_core_get_sset_count,
2881
	.get_drvinfo = qeth_core_get_drvinfo,
2882
	.get_link_ksettings = qeth_core_ethtool_get_link_ksettings,
2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908
};

/*
 * we need NOARP for IPv4 but we want neighbor solicitation for IPv6. Setting
 * NOARP on the netdevice is no option because it also turns off neighbor
 * solicitation. For IPv4 we install a neighbor_setup function. We don't want
 * arp resolution but we want the hard header (packet socket will work
 * e.g. tcpdump)
 */
static int qeth_l3_neigh_setup_noarp(struct neighbour *n)
{
	n->nud_state = NUD_NOARP;
	memcpy(n->ha, "FAKELL", 6);
	n->output = n->ops->connected_output;
	return 0;
}

static int
qeth_l3_neigh_setup(struct net_device *dev, struct neigh_parms *np)
{
	if (np->tbl->family == AF_INET)
		np->neigh_setup = qeth_l3_neigh_setup_noarp;

	return 0;
}

2909
static const struct net_device_ops qeth_l3_netdev_ops = {
2910 2911 2912 2913 2914
	.ndo_open		= qeth_l3_open,
	.ndo_stop		= qeth_l3_stop,
	.ndo_get_stats		= qeth_get_stats,
	.ndo_start_xmit		= qeth_l3_hard_start_xmit,
	.ndo_validate_addr	= eth_validate_addr,
2915
	.ndo_set_rx_mode	= qeth_l3_set_multicast_list,
2916
	.ndo_do_ioctl		= qeth_do_ioctl,
J
Jiri Pirko 已提交
2917
	.ndo_change_mtu		= qeth_change_mtu,
2918 2919
	.ndo_fix_features	= qeth_fix_features,
	.ndo_set_features	= qeth_set_features,
2920 2921
	.ndo_vlan_rx_add_vid	= qeth_l3_vlan_rx_add_vid,
	.ndo_vlan_rx_kill_vid   = qeth_l3_vlan_rx_kill_vid,
J
Jiri Pirko 已提交
2922
	.ndo_tx_timeout		= qeth_tx_timeout,
2923 2924
};

2925 2926 2927 2928 2929 2930
static const struct net_device_ops qeth_l3_osa_netdev_ops = {
	.ndo_open		= qeth_l3_open,
	.ndo_stop		= qeth_l3_stop,
	.ndo_get_stats		= qeth_get_stats,
	.ndo_start_xmit		= qeth_l3_hard_start_xmit,
	.ndo_validate_addr	= eth_validate_addr,
2931
	.ndo_set_rx_mode	= qeth_l3_set_multicast_list,
2932
	.ndo_do_ioctl		= qeth_do_ioctl,
J
Jiri Pirko 已提交
2933
	.ndo_change_mtu		= qeth_change_mtu,
2934 2935
	.ndo_fix_features	= qeth_fix_features,
	.ndo_set_features	= qeth_set_features,
2936 2937
	.ndo_vlan_rx_add_vid	= qeth_l3_vlan_rx_add_vid,
	.ndo_vlan_rx_kill_vid   = qeth_l3_vlan_rx_kill_vid,
J
Jiri Pirko 已提交
2938
	.ndo_tx_timeout		= qeth_tx_timeout,
2939 2940 2941
	.ndo_neigh_setup	= qeth_l3_neigh_setup,
};

2942 2943
static int qeth_l3_setup_netdev(struct qeth_card *card)
{
2944 2945
	int rc;

2946 2947
	if (card->info.type == QETH_CARD_TYPE_OSD ||
	    card->info.type == QETH_CARD_TYPE_OSX) {
2948 2949
		if ((card->info.link_type == QETH_LINK_TYPE_LANE_TR) ||
		    (card->info.link_type == QETH_LINK_TYPE_HSTR)) {
2950 2951
			pr_info("qeth_l3: ignoring TR device\n");
			return -ENODEV;
2952 2953 2954 2955
		} else {
			card->dev = alloc_etherdev(0);
			if (!card->dev)
				return -ENODEV;
2956
			card->dev->netdev_ops = &qeth_l3_osa_netdev_ops;
2957 2958 2959 2960 2961 2962

			/*IPv6 address autoconfiguration stuff*/
			qeth_l3_get_unique_id(card);
			if (!(card->info.unique_id & UNIQUE_ID_NOT_BY_CARD))
				card->dev->dev_id = card->info.unique_id &
							 0xffff;
2963 2964 2965 2966
			if (!card->info.guestlan) {
				card->dev->hw_features = NETIF_F_SG |
					NETIF_F_RXCSUM | NETIF_F_IP_CSUM |
					NETIF_F_TSO;
2967 2968 2969
				card->dev->vlan_features = NETIF_F_SG |
					NETIF_F_RXCSUM | NETIF_F_IP_CSUM |
					NETIF_F_TSO;
2970
			}
2971 2972
		}
	} else if (card->info.type == QETH_CARD_TYPE_IQD) {
2973 2974
		card->dev = alloc_netdev(0, "hsi%d", NET_NAME_UNKNOWN,
					 ether_setup);
2975 2976 2977
		if (!card->dev)
			return -ENODEV;
		card->dev->flags |= IFF_NOARP;
2978
		card->dev->netdev_ops = &qeth_l3_netdev_ops;
2979 2980 2981
		rc = qeth_l3_iqd_read_initial_mac(card);
		if (rc)
			return rc;
2982 2983
		if (card->options.hsuid[0])
			memcpy(card->dev->perm_addr, card->options.hsuid, 9);
2984 2985 2986
	} else
		return -ENODEV;

2987
	card->dev->ml_priv = card;
2988 2989
	card->dev->watchdog_timeo = QETH_TX_TIMEOUT;
	card->dev->mtu = card->info.initial_mtu;
2990 2991
	card->dev->min_mtu = 64;
	card->dev->max_mtu = ETH_MAX_MTU;
2992
	card->dev->ethtool_ops = &qeth_l3_ethtool_ops;
2993 2994 2995
	card->dev->features |=	NETIF_F_HW_VLAN_CTAG_TX |
				NETIF_F_HW_VLAN_CTAG_RX |
				NETIF_F_HW_VLAN_CTAG_FILTER;
2996
	netif_keep_dst(card->dev);
2997 2998
	card->dev->gso_max_size = (QETH_MAX_BUFFER_ELEMENTS(card) - 1) *
				  PAGE_SIZE;
2999 3000

	SET_NETDEV_DEV(card->dev, &card->gdev->dev);
3001
	netif_napi_add(card->dev, &card->napi, qeth_poll, QETH_NAPI_WEIGHT);
3002
	netif_carrier_off(card->dev);
3003 3004 3005
	return register_netdev(card->dev);
}

3006 3007 3008 3009 3010
static const struct device_type qeth_l3_devtype = {
	.name = "qeth_layer3",
	.groups = qeth_l3_attr_groups,
};

3011 3012 3013
static int qeth_l3_probe_device(struct ccwgroup_device *gdev)
{
	struct qeth_card *card = dev_get_drvdata(&gdev->dev);
3014
	int rc;
3015

3016 3017 3018 3019 3020
	if (gdev->dev.type == &qeth_generic_devtype) {
		rc = qeth_l3_create_device_attributes(&gdev->dev);
		if (rc)
			return rc;
	}
3021 3022
	hash_init(card->ip_htable);
	hash_init(card->ip_mc_htable);
3023
	card->options.layer2 = 0;
3024
	card->info.hwtrap = 0;
3025 3026 3027 3028 3029 3030 3031
	return 0;
}

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

3032 3033
	if (cgdev->dev.type == &qeth_generic_devtype)
		qeth_l3_remove_device_attributes(&cgdev->dev);
3034

3035
	qeth_set_allowed_threads(card, 0, 1);
3036 3037
	wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);

3038
	if (cgdev->state == CCWGROUP_ONLINE)
3039 3040 3041
		qeth_l3_set_offline(cgdev);

	if (card->dev) {
3042
		netif_napi_del(&card->napi);
3043 3044 3045 3046
		unregister_netdev(card->dev);
		card->dev = NULL;
	}

3047
	qeth_l3_clear_ip_htable(card, 0);
3048 3049 3050 3051 3052 3053 3054 3055 3056 3057
	qeth_l3_clear_ipato_list(card);
	return;
}

static int __qeth_l3_set_online(struct ccwgroup_device *gdev, int recovery_mode)
{
	struct qeth_card *card = dev_get_drvdata(&gdev->dev);
	int rc = 0;
	enum qeth_card_states recover_flag;

3058
	mutex_lock(&card->discipline_mutex);
3059
	mutex_lock(&card->conf_mutex);
3060 3061
	QETH_DBF_TEXT(SETUP, 2, "setonlin");
	QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
3062 3063 3064 3065

	recover_flag = card->state;
	rc = qeth_core_hardsetup_card(card);
	if (rc) {
3066
		QETH_DBF_TEXT_(SETUP, 2, "2err%04x", rc);
3067
		rc = -ENODEV;
3068 3069 3070
		goto out_remove;
	}

3071 3072
	if (!card->dev && qeth_l3_setup_netdev(card)) {
		rc = -ENODEV;
3073
		goto out_remove;
3074
	}
3075

3076 3077 3078 3079 3080 3081 3082
	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;

3083
	card->state = CARD_STATE_HARDSETUP;
3084
	memset(&card->rx, 0, sizeof(struct qeth_rx));
3085 3086 3087
	qeth_print_status_message(card);

	/* softsetup */
3088
	QETH_DBF_TEXT(SETUP, 2, "softsetp");
3089 3090 3091

	rc = qeth_l3_setadapter_parms(card);
	if (rc)
3092
		QETH_DBF_TEXT_(SETUP, 2, "2err%04x", rc);
3093 3094
	if (!card->options.sniffer) {
		rc = qeth_l3_start_ipassists(card);
S
Stefan Raspl 已提交
3095
		if (rc) {
3096
			QETH_DBF_TEXT_(SETUP, 2, "3err%d", rc);
S
Stefan Raspl 已提交
3097 3098
			goto out_remove;
		}
3099 3100
		rc = qeth_l3_setrouting_v4(card);
		if (rc)
3101
			QETH_DBF_TEXT_(SETUP, 2, "4err%04x", rc);
3102 3103
		rc = qeth_l3_setrouting_v6(card);
		if (rc)
3104
			QETH_DBF_TEXT_(SETUP, 2, "5err%04x", rc);
3105
	}
3106 3107 3108 3109
	netif_tx_disable(card->dev);

	rc = qeth_init_qdio_queues(card);
	if (rc) {
3110
		QETH_DBF_TEXT_(SETUP, 2, "6err%d", rc);
3111
		rc = -ENODEV;
3112 3113 3114 3115 3116
		goto out_remove;
	}
	card->state = CARD_STATE_SOFTSETUP;

	qeth_set_allowed_threads(card, 0xffffffff, 0);
3117
	qeth_l3_recover_ip(card);
3118 3119 3120 3121
	if (card->lan_online)
		netif_carrier_on(card->dev);
	else
		netif_carrier_off(card->dev);
3122
	if (recover_flag == CARD_STATE_RECOVER) {
3123
		rtnl_lock();
3124
		if (recovery_mode)
3125
			__qeth_l3_open(card->dev);
3126
		else
3127 3128
			dev_open(card->dev);
		qeth_l3_set_multicast_list(card->dev);
3129
		qeth_recover_features(card->dev);
3130
		rtnl_unlock();
3131
	}
S
Stefan Raspl 已提交
3132
	qeth_trace_features(card);
3133 3134
	/* let user_space know that device is online */
	kobject_uevent(&gdev->dev.kobj, KOBJ_CHANGE);
3135
	mutex_unlock(&card->conf_mutex);
3136
	mutex_unlock(&card->discipline_mutex);
3137 3138 3139 3140 3141 3142
	return 0;
out_remove:
	qeth_l3_stop_card(card, 0);
	ccw_device_set_offline(CARD_DDEV(card));
	ccw_device_set_offline(CARD_WDEV(card));
	ccw_device_set_offline(CARD_RDEV(card));
3143
	qdio_free(CARD_DDEV(card));
3144 3145 3146 3147
	if (recover_flag == CARD_STATE_RECOVER)
		card->state = CARD_STATE_RECOVER;
	else
		card->state = CARD_STATE_DOWN;
3148
	mutex_unlock(&card->conf_mutex);
3149
	mutex_unlock(&card->discipline_mutex);
3150
	return rc;
3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164
}

static int qeth_l3_set_online(struct ccwgroup_device *gdev)
{
	return __qeth_l3_set_online(gdev, 0);
}

static int __qeth_l3_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;
	enum qeth_card_states recover_flag;

3165
	mutex_lock(&card->discipline_mutex);
3166
	mutex_lock(&card->conf_mutex);
3167 3168
	QETH_DBF_TEXT(SETUP, 3, "setoffl");
	QETH_DBF_HEX(SETUP, 3, &card, sizeof(void *));
3169 3170 3171 3172

	if (card->dev && netif_carrier_ok(card->dev))
		netif_carrier_off(card->dev);
	recover_flag = card->state;
3173 3174 3175 3176
	if ((!recovery_mode && card->info.hwtrap) || card->info.hwtrap == 2) {
		qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
		card->info.hwtrap = 1;
	}
3177
	qeth_l3_stop_card(card, recovery_mode);
3178 3179 3180 3181 3182
	if ((card->options.cq == QETH_CQ_ENABLED) && card->dev) {
		rtnl_lock();
		call_netdevice_notifiers(NETDEV_REBOOT, card->dev);
		rtnl_unlock();
	}
3183 3184 3185 3186 3187 3188
	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)
3189
		QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
3190
	qdio_free(CARD_DDEV(card));
3191 3192 3193 3194
	if (recover_flag == CARD_STATE_UP)
		card->state = CARD_STATE_RECOVER;
	/* let user_space know that device is offline */
	kobject_uevent(&cgdev->dev.kobj, KOBJ_CHANGE);
3195
	mutex_unlock(&card->conf_mutex);
3196
	mutex_unlock(&card->discipline_mutex);
3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210
	return 0;
}

static int qeth_l3_set_offline(struct ccwgroup_device *cgdev)
{
	return __qeth_l3_set_offline(cgdev, 0);
}

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

	card = (struct qeth_card *) ptr;
3211 3212
	QETH_CARD_TEXT(card, 2, "recover1");
	QETH_CARD_HEX(card, 2, &card, sizeof(void *));
3213 3214
	if (!qeth_do_run_thread(card, QETH_RECOVER_THREAD))
		return 0;
3215
	QETH_CARD_TEXT(card, 2, "recover2");
3216 3217
	dev_warn(&card->gdev->dev,
		"A recovery process has been started for the device\n");
3218
	qeth_set_recovery_task(card);
3219 3220 3221
	__qeth_l3_set_offline(card->gdev, 1);
	rc = __qeth_l3_set_online(card->gdev, 1);
	if (!rc)
3222 3223
		dev_info(&card->gdev->dev,
			"Device successfully recovered!\n");
3224
	else {
S
Stefan Raspl 已提交
3225 3226
		qeth_close_dev(card);
		dev_warn(&card->gdev->dev, "The qeth device driver "
3227
				"failed to recover an error on the device\n");
3228
	}
3229
	qeth_clear_recovery_task(card);
3230 3231
	qeth_clear_thread_start_bit(card, QETH_RECOVER_THREAD);
	qeth_clear_thread_running_bit(card, QETH_RECOVER_THREAD);
3232 3233 3234
	return 0;
}

3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245
static int qeth_l3_pm_suspend(struct ccwgroup_device *gdev)
{
	struct qeth_card *card = dev_get_drvdata(&gdev->dev);

	if (card->dev)
		netif_device_detach(card->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;
	if (card->state == CARD_STATE_UP) {
3246 3247
		if (card->info.hwtrap)
			qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264
		__qeth_l3_set_offline(card->gdev, 1);
	} else
		__qeth_l3_set_offline(card->gdev, 0);
	return 0;
}

static int qeth_l3_pm_resume(struct ccwgroup_device *gdev)
{
	struct qeth_card *card = dev_get_drvdata(&gdev->dev);
	int rc = 0;

	if (gdev->state == CCWGROUP_OFFLINE)
		goto out;

	if (card->state == CARD_STATE_RECOVER) {
		rc = __qeth_l3_set_online(card->gdev, 1);
		if (rc) {
3265 3266 3267
			rtnl_lock();
			dev_close(card->dev);
			rtnl_unlock();
3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280
		}
	} else
		rc = __qeth_l3_set_online(card->gdev, 0);
out:
	qeth_set_allowed_threads(card, 0xffffffff, 0);
	if (card->dev)
		netif_device_attach(card->dev);
	if (rc)
		dev_warn(&card->gdev->dev, "The qeth device driver "
			"failed to recover an error on the device\n");
	return rc;
}

3281 3282 3283 3284 3285 3286 3287
/* Returns zero if the command is successfully "consumed" */
static int qeth_l3_control_event(struct qeth_card *card,
					struct qeth_ipa_cmd *cmd)
{
	return 1;
}

3288
struct qeth_discipline qeth_l3_discipline = {
3289
	.devtype = &qeth_l3_devtype,
3290 3291 3292
	.start_poll = qeth_qdio_start_poll,
	.input_handler = (qdio_handler_t *) qeth_qdio_input_handler,
	.output_handler = (qdio_handler_t *) qeth_qdio_output_handler,
3293
	.process_rx_buffer = qeth_l3_process_inbound_buffer,
3294 3295
	.recover = qeth_l3_recover,
	.setup = qeth_l3_probe_device,
3296 3297 3298
	.remove = qeth_l3_remove_device,
	.set_online = qeth_l3_set_online,
	.set_offline = qeth_l3_set_offline,
3299 3300 3301
	.freeze = qeth_l3_pm_suspend,
	.thaw = qeth_l3_pm_resume,
	.restore = qeth_l3_pm_resume,
3302
	.do_ioctl = qeth_l3_do_ioctl,
3303
	.control_event_handler = qeth_l3_control_event,
3304
};
3305
EXPORT_SYMBOL_GPL(qeth_l3_discipline);
3306 3307

static int qeth_l3_ip_event(struct notifier_block *this,
3308
			    unsigned long event, void *ptr)
3309
{
3310

3311 3312 3313 3314 3315
	struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
	struct net_device *dev = (struct net_device *)ifa->ifa_dev->dev;
	struct qeth_ipaddr *addr;
	struct qeth_card *card;

3316
	if (dev_net(dev) != &init_net)
3317 3318
		return NOTIFY_DONE;

3319 3320 3321
	card = qeth_l3_get_card_from_dev(dev);
	if (!card)
		return NOTIFY_DONE;
3322
	QETH_CARD_TEXT(card, 3, "ipevent");
3323 3324

	addr = qeth_l3_get_addr_buffer(QETH_PROT_IPV4);
3325
	if (addr) {
3326 3327
		addr->u.a4.addr = be32_to_cpu(ifa->ifa_address);
		addr->u.a4.mask = be32_to_cpu(ifa->ifa_mask);
3328 3329
		addr->type = QETH_IP_TYPE_NORMAL;
	} else
3330
		return NOTIFY_DONE;
3331 3332 3333

	switch (event) {
	case NETDEV_UP:
3334 3335 3336
		spin_lock_bh(&card->ip_lock);
		qeth_l3_add_ip(card, addr);
		spin_unlock_bh(&card->ip_lock);
3337 3338
		break;
	case NETDEV_DOWN:
3339 3340 3341
		spin_lock_bh(&card->ip_lock);
		qeth_l3_delete_ip(card, addr);
		spin_unlock_bh(&card->ip_lock);
3342 3343
		break;
	}
3344 3345

	kfree(addr);
3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358
	return NOTIFY_DONE;
}

static struct notifier_block qeth_l3_ip_notifier = {
	qeth_l3_ip_event,
	NULL,
};

#ifdef CONFIG_QETH_IPV6
/**
 * IPv6 event handler
 */
static int qeth_l3_ip6_event(struct notifier_block *this,
3359
			     unsigned long event, void *ptr)
3360 3361 3362 3363 3364 3365 3366 3367 3368
{
	struct inet6_ifaddr *ifa = (struct inet6_ifaddr *)ptr;
	struct net_device *dev = (struct net_device *)ifa->idev->dev;
	struct qeth_ipaddr *addr;
	struct qeth_card *card;

	card = qeth_l3_get_card_from_dev(dev);
	if (!card)
		return NOTIFY_DONE;
3369
	QETH_CARD_TEXT(card, 3, "ip6event");
3370 3371 3372 3373
	if (!qeth_is_supported(card, IPA_IPV6))
		return NOTIFY_DONE;

	addr = qeth_l3_get_addr_buffer(QETH_PROT_IPV6);
3374
	if (addr) {
3375 3376 3377 3378
		memcpy(&addr->u.a6.addr, &ifa->addr, sizeof(struct in6_addr));
		addr->u.a6.pfxlen = ifa->prefix_len;
		addr->type = QETH_IP_TYPE_NORMAL;
	} else
3379
		return NOTIFY_DONE;
3380 3381 3382

	switch (event) {
	case NETDEV_UP:
3383 3384 3385
		spin_lock_bh(&card->ip_lock);
		qeth_l3_add_ip(card, addr);
		spin_unlock_bh(&card->ip_lock);
3386 3387
		break;
	case NETDEV_DOWN:
3388 3389 3390
		spin_lock_bh(&card->ip_lock);
		qeth_l3_delete_ip(card, addr);
		spin_unlock_bh(&card->ip_lock);
3391 3392
		break;
	}
3393 3394

	kfree(addr);
3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407
	return NOTIFY_DONE;
}

static struct notifier_block qeth_l3_ip6_notifier = {
	qeth_l3_ip6_event,
	NULL,
};
#endif

static int qeth_l3_register_notifiers(void)
{
	int rc;

3408
	QETH_DBF_TEXT(SETUP, 5, "regnotif");
3409 3410 3411 3412 3413 3414 3415 3416 3417 3418
	rc = register_inetaddr_notifier(&qeth_l3_ip_notifier);
	if (rc)
		return rc;
#ifdef CONFIG_QETH_IPV6
	rc = register_inet6addr_notifier(&qeth_l3_ip6_notifier);
	if (rc) {
		unregister_inetaddr_notifier(&qeth_l3_ip_notifier);
		return rc;
	}
#else
3419
	pr_warn("There is no IPv6 support for the layer 3 discipline\n");
3420 3421 3422 3423 3424 3425 3426
#endif
	return 0;
}

static void qeth_l3_unregister_notifiers(void)
{

3427
	QETH_DBF_TEXT(SETUP, 5, "unregnot");
S
Stefan Raspl 已提交
3428
	WARN_ON(unregister_inetaddr_notifier(&qeth_l3_ip_notifier));
3429
#ifdef CONFIG_QETH_IPV6
S
Stefan Raspl 已提交
3430
	WARN_ON(unregister_inet6addr_notifier(&qeth_l3_ip6_notifier));
3431 3432 3433 3434 3435 3436 3437
#endif /* QETH_IPV6 */
}

static int __init qeth_l3_init(void)
{
	int rc = 0;

3438
	pr_info("register layer 3 discipline\n");
3439 3440 3441 3442 3443 3444 3445
	rc = qeth_l3_register_notifiers();
	return rc;
}

static void __exit qeth_l3_exit(void)
{
	qeth_l3_unregister_notifiers();
3446
	pr_info("unregister layer 3 discipline\n");
3447 3448 3449 3450 3451 3452 3453
}

module_init(qeth_l3_init);
module_exit(qeth_l3_exit);
MODULE_AUTHOR("Frank Blaschka <frank.blaschka@de.ibm.com>");
MODULE_DESCRIPTION("qeth layer 3 discipline");
MODULE_LICENSE("GPL");
新手
引导
客服 返回
顶部