2017-11-14 20:38:04 +03:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2008-02-15 11:19:42 +03:00
|
|
|
/*
|
2009-06-16 12:30:31 +04:00
|
|
|
* Copyright IBM Corp. 2007, 2009
|
2008-02-15 11:19:42 +03:00
|
|
|
* 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>
|
|
|
|
*/
|
|
|
|
|
2008-12-25 15:39:49 +03:00
|
|
|
#define KMSG_COMPONENT "qeth"
|
|
|
|
#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
|
|
|
|
|
2008-02-15 11:19:42 +03:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/moduleparam.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/kernel.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 11:04:11 +03:00
|
|
|
#include <linux/slab.h>
|
2008-02-15 11:19:42 +03:00
|
|
|
#include <linux/etherdevice.h>
|
2009-05-23 03:22:17 +04:00
|
|
|
#include <linux/list.h>
|
2015-10-06 16:12:28 +03:00
|
|
|
#include <linux/hash.h>
|
|
|
|
#include <linux/hashtable.h>
|
2017-06-20 17:00:34 +03:00
|
|
|
#include <asm/setup.h>
|
2008-02-15 11:19:42 +03:00
|
|
|
#include "qeth_core.h"
|
2014-01-14 18:54:11 +04:00
|
|
|
#include "qeth_l2.h"
|
2008-02-15 11:19:42 +03:00
|
|
|
|
2014-01-29 12:23:48 +04:00
|
|
|
static void qeth_bridgeport_query_support(struct qeth_card *card);
|
|
|
|
static void qeth_bridge_state_change(struct qeth_card *card,
|
|
|
|
struct qeth_ipa_cmd *cmd);
|
|
|
|
static void qeth_bridge_host_event(struct qeth_card *card,
|
|
|
|
struct qeth_ipa_cmd *cmd);
|
2017-09-18 22:18:15 +03:00
|
|
|
static void qeth_l2_vnicc_set_defaults(struct qeth_card *card);
|
s390/qeth: add basic VNICC support
VNIC Characteristics (VNICC) are features of HiperSockets that define
how packets are handled by the underlying network hardware. For example,
if the VNICC flooding is configured on a qeth device, ethernet frames to
unknown destination MAC addresses are received.
Currently, there is support for seven VNICCs: flooding, multicast
flooding, receive broadcast, learning, takeover learning, takeover
setvmac, bridge invisible. Also, six IPA commands exist for configuring
VNICCs on a qeth device: query characteristics, query commands, enable
characteristic, disable characteristic, set timeout, get timeout.
This patch adds the basic code infrastructure for VNICC support to qeth.
It allows querying VNICC support from the underlying hardware. To this
end, it adds:
* basic message formats for IPA commands
* basic data structures
* basic error handling
* query characteristics IPA command support
The query characteristics IPA command allows requesting the currently
supported and currently enabled VNIC characteristics from the underlying
hardware.
Support for the other IPA commands and for the configuration of VNICCs
is added in follow-up patches together with the respective user
interface functions.
Signed-off-by: Hans Wippel <hwippel@linux.vnet.ibm.com>
Reviewed-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-09-18 22:18:14 +03:00
|
|
|
static void qeth_l2_vnicc_init(struct qeth_card *card);
|
2017-09-18 22:18:16 +03:00
|
|
|
static bool qeth_l2_vnicc_recover_timeout(struct qeth_card *card, u32 vnicc,
|
|
|
|
u32 *timeout);
|
2008-02-15 11:19:42 +03:00
|
|
|
|
2019-02-12 20:33:25 +03:00
|
|
|
static int qeth_l2_setdelmac_makerc(struct qeth_card *card, u16 retcode)
|
2008-02-15 11:19:42 +03:00
|
|
|
{
|
2015-01-21 15:39:09 +03:00
|
|
|
int rc;
|
2008-02-15 11:19:42 +03:00
|
|
|
|
2015-01-21 15:39:09 +03:00
|
|
|
if (retcode)
|
2015-01-21 15:39:10 +03:00
|
|
|
QETH_CARD_TEXT_(card, 2, "err%04x", retcode);
|
2015-01-21 15:39:09 +03:00
|
|
|
switch (retcode) {
|
|
|
|
case IPA_RC_SUCCESS:
|
|
|
|
rc = 0;
|
|
|
|
break;
|
|
|
|
case IPA_RC_L2_UNSUPPORTED_CMD:
|
2015-05-18 15:27:58 +03:00
|
|
|
rc = -EOPNOTSUPP;
|
2015-01-21 15:39:09 +03:00
|
|
|
break;
|
|
|
|
case IPA_RC_L2_ADDR_TABLE_FULL:
|
|
|
|
rc = -ENOSPC;
|
|
|
|
break;
|
|
|
|
case IPA_RC_L2_DUP_MAC:
|
|
|
|
case IPA_RC_L2_DUP_LAYER3_MAC:
|
2020-03-25 12:35:05 +03:00
|
|
|
rc = -EADDRINUSE;
|
2015-01-21 15:39:09 +03:00
|
|
|
break;
|
|
|
|
case IPA_RC_L2_MAC_NOT_AUTH_BY_HYP:
|
|
|
|
case IPA_RC_L2_MAC_NOT_AUTH_BY_ADP:
|
2020-03-25 12:35:05 +03:00
|
|
|
rc = -EADDRNOTAVAIL;
|
2015-01-21 15:39:09 +03:00
|
|
|
break;
|
|
|
|
case IPA_RC_L2_MAC_NOT_FOUND:
|
|
|
|
rc = -ENOENT;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
rc = -EIO;
|
|
|
|
break;
|
2008-02-15 11:19:42 +03:00
|
|
|
}
|
2015-01-21 15:39:09 +03:00
|
|
|
return rc;
|
2008-02-15 11:19:42 +03:00
|
|
|
}
|
|
|
|
|
2019-02-12 20:33:25 +03:00
|
|
|
static int qeth_l2_send_setdelmac_cb(struct qeth_card *card,
|
|
|
|
struct qeth_reply *reply,
|
|
|
|
unsigned long data)
|
|
|
|
{
|
|
|
|
struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
|
|
|
|
|
|
|
|
return qeth_l2_setdelmac_makerc(card, cmd->hdr.return_code);
|
|
|
|
}
|
|
|
|
|
2017-01-12 17:48:41 +03:00
|
|
|
static int qeth_l2_send_setdelmac(struct qeth_card *card, __u8 *mac,
|
|
|
|
enum qeth_ipa_cmds ipacmd)
|
|
|
|
{
|
|
|
|
struct qeth_ipa_cmd *cmd;
|
|
|
|
struct qeth_cmd_buffer *iob;
|
|
|
|
|
|
|
|
QETH_CARD_TEXT(card, 2, "L2sdmac");
|
2019-06-27 18:01:22 +03:00
|
|
|
iob = qeth_ipa_alloc_cmd(card, ipacmd, QETH_PROT_IPV4,
|
|
|
|
IPA_DATA_SIZEOF(setdelmac));
|
2017-01-12 17:48:41 +03:00
|
|
|
if (!iob)
|
|
|
|
return -ENOMEM;
|
2018-03-09 20:12:52 +03:00
|
|
|
cmd = __ipa_cmd(iob);
|
2017-12-20 22:11:01 +03:00
|
|
|
cmd->data.setdelmac.mac_length = ETH_ALEN;
|
|
|
|
ether_addr_copy(cmd->data.setdelmac.mac, mac);
|
2019-02-12 20:33:25 +03:00
|
|
|
return qeth_send_ipa_cmd(card, iob, qeth_l2_send_setdelmac_cb, NULL);
|
2017-01-12 17:48:41 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static int qeth_l2_send_setmac(struct qeth_card *card, __u8 *mac)
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
QETH_CARD_TEXT(card, 2, "L2Setmac");
|
|
|
|
rc = qeth_l2_send_setdelmac(card, mac, IPA_CMD_SETVMAC);
|
|
|
|
if (rc == 0) {
|
|
|
|
dev_info(&card->gdev->dev,
|
2019-01-25 17:44:19 +03:00
|
|
|
"MAC address %pM successfully registered\n", mac);
|
2017-01-12 17:48:41 +03:00
|
|
|
} else {
|
|
|
|
switch (rc) {
|
2020-03-25 12:35:05 +03:00
|
|
|
case -EADDRINUSE:
|
2017-01-12 17:48:41 +03:00
|
|
|
dev_warn(&card->gdev->dev,
|
|
|
|
"MAC address %pM already exists\n", mac);
|
|
|
|
break;
|
2020-03-25 12:35:05 +03:00
|
|
|
case -EADDRNOTAVAIL:
|
2017-01-12 17:48:41 +03:00
|
|
|
dev_warn(&card->gdev->dev,
|
|
|
|
"MAC address %pM is not authorized\n", mac);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2017-12-20 22:11:00 +03:00
|
|
|
static int qeth_l2_write_mac(struct qeth_card *card, u8 *mac)
|
2008-02-15 11:19:42 +03:00
|
|
|
{
|
s390/qeth: avoid using is_multicast_ether_addr_64bits on (u8 *)[6]
*ether_addr*_64bits functions have been introduced to optimize
performance critical paths, which access 6-byte ethernet address as u64
value to get "nice" assembly. A harmless hack works nicely on ethernet
addresses shoved into a structure or a larger buffer, until busted by
Kasan on smth like plain (u8 *)[6].
qeth_l2_set_mac_address calls qeth_l2_remove_mac passing
u8 old_addr[ETH_ALEN] as an argument.
Adding/removing macs for an ethernet adapter is not that performance
critical. Moreover is_multicast_ether_addr_64bits itself on s390 is not
faster than is_multicast_ether_addr:
is_multicast_ether_addr(%r2) -> %r2
llc %r2,0(%r2)
risbg %r2,%r2,63,191,0
is_multicast_ether_addr_64bits(%r2) -> %r2
llgc %r2,0(%r2)
risbg %r2,%r2,63,191,0
So, let's just use is_multicast_ether_addr instead of
is_multicast_ether_addr_64bits.
Fixes: bcacfcbc82b4 ("s390/qeth: fix MAC address update sequence")
Reviewed-by: Julian Wiedmann <jwi@linux.ibm.com>
Signed-off-by: Vasily Gorbik <gor@linux.ibm.com>
Signed-off-by: Julian Wiedmann <jwi@linux.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2018-06-29 20:45:52 +03:00
|
|
|
enum qeth_ipa_cmds cmd = is_multicast_ether_addr(mac) ?
|
2017-12-20 22:11:00 +03:00
|
|
|
IPA_CMD_SETGMAC : IPA_CMD_SETVMAC;
|
2015-01-21 15:39:09 +03:00
|
|
|
int rc;
|
2008-02-15 11:19:42 +03:00
|
|
|
|
2017-12-20 22:11:00 +03:00
|
|
|
QETH_CARD_TEXT(card, 2, "L2Wmac");
|
|
|
|
rc = qeth_l2_send_setdelmac(card, mac, cmd);
|
2020-03-25 12:35:05 +03:00
|
|
|
if (rc == -EADDRINUSE)
|
2018-11-02 21:04:08 +03:00
|
|
|
QETH_DBF_MESSAGE(2, "MAC already registered on device %x\n",
|
|
|
|
CARD_DEVID(card));
|
2015-01-21 15:39:09 +03:00
|
|
|
else if (rc)
|
2018-11-02 21:04:08 +03:00
|
|
|
QETH_DBF_MESSAGE(2, "Failed to register MAC on device %x: %d\n",
|
|
|
|
CARD_DEVID(card), rc);
|
2015-01-21 15:39:09 +03:00
|
|
|
return rc;
|
2008-02-15 11:19:42 +03:00
|
|
|
}
|
|
|
|
|
2017-12-20 22:11:00 +03:00
|
|
|
static int qeth_l2_remove_mac(struct qeth_card *card, u8 *mac)
|
2008-02-15 11:19:42 +03:00
|
|
|
{
|
s390/qeth: avoid using is_multicast_ether_addr_64bits on (u8 *)[6]
*ether_addr*_64bits functions have been introduced to optimize
performance critical paths, which access 6-byte ethernet address as u64
value to get "nice" assembly. A harmless hack works nicely on ethernet
addresses shoved into a structure or a larger buffer, until busted by
Kasan on smth like plain (u8 *)[6].
qeth_l2_set_mac_address calls qeth_l2_remove_mac passing
u8 old_addr[ETH_ALEN] as an argument.
Adding/removing macs for an ethernet adapter is not that performance
critical. Moreover is_multicast_ether_addr_64bits itself on s390 is not
faster than is_multicast_ether_addr:
is_multicast_ether_addr(%r2) -> %r2
llc %r2,0(%r2)
risbg %r2,%r2,63,191,0
is_multicast_ether_addr_64bits(%r2) -> %r2
llgc %r2,0(%r2)
risbg %r2,%r2,63,191,0
So, let's just use is_multicast_ether_addr instead of
is_multicast_ether_addr_64bits.
Fixes: bcacfcbc82b4 ("s390/qeth: fix MAC address update sequence")
Reviewed-by: Julian Wiedmann <jwi@linux.ibm.com>
Signed-off-by: Vasily Gorbik <gor@linux.ibm.com>
Signed-off-by: Julian Wiedmann <jwi@linux.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2018-06-29 20:45:52 +03:00
|
|
|
enum qeth_ipa_cmds cmd = is_multicast_ether_addr(mac) ?
|
2017-12-20 22:11:00 +03:00
|
|
|
IPA_CMD_DELGMAC : IPA_CMD_DELVMAC;
|
2015-01-21 15:39:09 +03:00
|
|
|
int rc;
|
|
|
|
|
2017-12-20 22:11:00 +03:00
|
|
|
QETH_CARD_TEXT(card, 2, "L2Rmac");
|
|
|
|
rc = qeth_l2_send_setdelmac(card, mac, cmd);
|
2015-01-21 15:39:09 +03:00
|
|
|
if (rc)
|
2018-11-02 21:04:08 +03:00
|
|
|
QETH_DBF_MESSAGE(2, "Failed to delete MAC on device %u: %d\n",
|
|
|
|
CARD_DEVID(card), rc);
|
2015-01-21 15:39:09 +03:00
|
|
|
return rc;
|
2008-02-15 11:19:42 +03:00
|
|
|
}
|
|
|
|
|
2019-03-28 18:39:19 +03:00
|
|
|
static void qeth_l2_drain_rx_mode_cache(struct qeth_card *card)
|
2008-02-15 11:19:42 +03:00
|
|
|
{
|
2015-10-06 16:12:28 +03:00
|
|
|
struct qeth_mac *mac;
|
|
|
|
struct hlist_node *tmp;
|
|
|
|
int i;
|
2008-02-15 11:19:42 +03:00
|
|
|
|
2015-10-06 16:12:28 +03:00
|
|
|
hash_for_each_safe(card->mac_htable, i, tmp, mac, hnode) {
|
|
|
|
hash_del(&mac->hnode);
|
|
|
|
kfree(mac);
|
2008-02-15 11:19:42 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-02-15 21:22:29 +03:00
|
|
|
static void qeth_l2_fill_header(struct qeth_qdio_out_q *queue,
|
|
|
|
struct qeth_hdr *hdr, struct sk_buff *skb,
|
2019-06-27 18:01:33 +03:00
|
|
|
int ipv, unsigned int data_len)
|
2008-02-15 11:19:42 +03:00
|
|
|
{
|
2019-06-27 18:01:33 +03:00
|
|
|
int cast_type = qeth_get_ether_cast_type(skb);
|
2018-10-12 18:27:15 +03:00
|
|
|
struct vlan_ethhdr *veth = vlan_eth_hdr(skb);
|
2008-02-15 11:19:42 +03:00
|
|
|
|
2017-08-18 11:19:05 +03:00
|
|
|
hdr->hdr.l2.pkt_length = data_len;
|
2008-02-15 11:19:42 +03:00
|
|
|
|
2018-10-12 18:27:15 +03:00
|
|
|
if (skb_is_gso(skb)) {
|
|
|
|
hdr->hdr.l2.id = QETH_HEADER_TYPE_L2_TSO;
|
|
|
|
} else {
|
|
|
|
hdr->hdr.l2.id = QETH_HEADER_TYPE_LAYER2;
|
2019-08-23 12:48:49 +03:00
|
|
|
if (skb->ip_summed == CHECKSUM_PARTIAL)
|
2018-10-12 18:27:15 +03:00
|
|
|
qeth_tx_csum(skb, &hdr->hdr.l2.flags[1], ipv);
|
2018-09-17 18:35:55 +03:00
|
|
|
}
|
|
|
|
|
2008-02-15 11:19:42 +03:00
|
|
|
/* set byte byte 3 to casting flags */
|
|
|
|
if (cast_type == RTN_MULTICAST)
|
|
|
|
hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_MULTICAST;
|
|
|
|
else if (cast_type == RTN_BROADCAST)
|
|
|
|
hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_BROADCAST;
|
|
|
|
else
|
2009-08-26 06:01:08 +04:00
|
|
|
hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_UNICAST;
|
2008-02-15 11:19:42 +03:00
|
|
|
|
|
|
|
/* VSWITCH relies on the VLAN
|
|
|
|
* information to be present in
|
|
|
|
* the QDIO header */
|
|
|
|
if (veth->h_vlan_proto == __constant_htons(ETH_P_8021Q)) {
|
|
|
|
hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_VLAN;
|
|
|
|
hdr->hdr.l2.vlan_id = ntohs(veth->h_vlan_TCI);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-02-12 20:33:25 +03:00
|
|
|
static int qeth_l2_setdelvlan_makerc(struct qeth_card *card, u16 retcode)
|
2017-09-18 22:18:20 +03:00
|
|
|
{
|
|
|
|
if (retcode)
|
|
|
|
QETH_CARD_TEXT_(card, 2, "err%04x", retcode);
|
|
|
|
|
|
|
|
switch (retcode) {
|
|
|
|
case IPA_RC_SUCCESS:
|
|
|
|
return 0;
|
|
|
|
case IPA_RC_L2_INVALID_VLAN_ID:
|
|
|
|
return -EINVAL;
|
|
|
|
case IPA_RC_L2_DUP_VLAN_ID:
|
|
|
|
return -EEXIST;
|
|
|
|
case IPA_RC_L2_VLAN_ID_NOT_FOUND:
|
|
|
|
return -ENOENT;
|
|
|
|
case IPA_RC_L2_VLAN_ID_NOT_ALLOWED:
|
|
|
|
return -EPERM;
|
|
|
|
default:
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-02-15 11:19:42 +03:00
|
|
|
static int qeth_l2_send_setdelvlan_cb(struct qeth_card *card,
|
2017-09-18 22:18:20 +03:00
|
|
|
struct qeth_reply *reply,
|
|
|
|
unsigned long data)
|
2008-02-15 11:19:42 +03:00
|
|
|
{
|
2017-09-18 22:18:20 +03:00
|
|
|
struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
|
2008-02-15 11:19:42 +03:00
|
|
|
|
2010-06-22 02:57:05 +04:00
|
|
|
QETH_CARD_TEXT(card, 2, "L2sdvcb");
|
2008-02-15 11:19:42 +03:00
|
|
|
if (cmd->hdr.return_code) {
|
2018-11-02 21:04:08 +03:00
|
|
|
QETH_DBF_MESSAGE(2, "Error in processing VLAN %u on device %x: %#x.\n",
|
2017-09-18 22:18:20 +03:00
|
|
|
cmd->data.setdelvlan.vlan_id,
|
2018-11-02 21:04:08 +03:00
|
|
|
CARD_DEVID(card), cmd->hdr.return_code);
|
2010-06-22 02:57:05 +04:00
|
|
|
QETH_CARD_TEXT_(card, 2, "L2VL%4x", cmd->hdr.command);
|
2008-02-15 11:19:42 +03:00
|
|
|
}
|
2019-02-12 20:33:25 +03:00
|
|
|
return qeth_l2_setdelvlan_makerc(card, cmd->hdr.return_code);
|
2008-02-15 11:19:42 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static int qeth_l2_send_setdelvlan(struct qeth_card *card, __u16 i,
|
2017-09-18 22:18:20 +03:00
|
|
|
enum qeth_ipa_cmds ipacmd)
|
2008-02-15 11:19:42 +03:00
|
|
|
{
|
|
|
|
struct qeth_ipa_cmd *cmd;
|
|
|
|
struct qeth_cmd_buffer *iob;
|
|
|
|
|
2010-06-22 02:57:05 +04:00
|
|
|
QETH_CARD_TEXT_(card, 4, "L2sdv%x", ipacmd);
|
2019-06-27 18:01:22 +03:00
|
|
|
iob = qeth_ipa_alloc_cmd(card, ipacmd, QETH_PROT_IPV4,
|
|
|
|
IPA_DATA_SIZEOF(setdelvlan));
|
2015-01-21 15:39:10 +03:00
|
|
|
if (!iob)
|
|
|
|
return -ENOMEM;
|
2018-03-09 20:12:52 +03:00
|
|
|
cmd = __ipa_cmd(iob);
|
2008-02-15 11:19:42 +03:00
|
|
|
cmd->data.setdelvlan.vlan_id = i;
|
2019-02-12 20:33:25 +03:00
|
|
|
return qeth_send_ipa_cmd(card, iob, qeth_l2_send_setdelvlan_cb, NULL);
|
2008-02-15 11:19:42 +03:00
|
|
|
}
|
|
|
|
|
2013-04-19 06:04:28 +04:00
|
|
|
static int qeth_l2_vlan_rx_add_vid(struct net_device *dev,
|
|
|
|
__be16 proto, u16 vid)
|
2008-02-15 11:19:42 +03:00
|
|
|
{
|
2008-07-26 13:24:10 +04:00
|
|
|
struct qeth_card *card = dev->ml_priv;
|
2008-02-15 11:19:42 +03:00
|
|
|
|
2010-06-22 02:57:05 +04:00
|
|
|
QETH_CARD_TEXT_(card, 4, "aid:%d", vid);
|
2010-10-01 06:51:13 +04:00
|
|
|
if (!vid)
|
2011-12-09 04:52:37 +04:00
|
|
|
return 0;
|
2019-01-25 17:44:22 +03:00
|
|
|
|
2019-01-25 17:44:23 +03:00
|
|
|
return qeth_l2_send_setdelvlan(card, vid, IPA_CMD_SETVLAN);
|
2008-02-15 11:19:42 +03:00
|
|
|
}
|
|
|
|
|
2013-04-19 06:04:28 +04:00
|
|
|
static int qeth_l2_vlan_rx_kill_vid(struct net_device *dev,
|
|
|
|
__be16 proto, u16 vid)
|
2008-02-15 11:19:42 +03:00
|
|
|
{
|
2008-07-26 13:24:10 +04:00
|
|
|
struct qeth_card *card = dev->ml_priv;
|
2008-02-15 11:19:42 +03:00
|
|
|
|
2010-06-22 02:57:05 +04:00
|
|
|
QETH_CARD_TEXT_(card, 4, "kid:%d", vid);
|
2019-01-25 17:44:23 +03:00
|
|
|
if (!vid)
|
|
|
|
return 0;
|
2019-01-25 17:44:22 +03:00
|
|
|
|
2019-01-25 17:44:23 +03:00
|
|
|
return qeth_l2_send_setdelvlan(card, vid, IPA_CMD_DELVLAN);
|
2008-02-15 11:19:42 +03:00
|
|
|
}
|
|
|
|
|
s390/qeth: call dev_close() during recovery
When resetting an interface ("recovery"), qeth currently attempts to
elide the call to dev_close(). We initially only call .ndo_close to
quiesce the data path, and then offline & online the ccwgroup device.
If the reset succeeded, a call to .ndo_open then resumes the data path
along with some internal setup (dev_addr validation, RX modeset) that
dev_open() would have usually triggered.
dev_close() only gets called (via the close_dev worker) if the reset
action fails.
It's unclear whether this was initially done due to locking concerns, or
rather to execute the reset transparently. Either way, temporarily
closing the interface without dev_close() is fragile, and means we're
susceptible to various races and unexpected behaviour. For instance:
- Bypassing dev_deactivate_many() means that the qdiscs are not set to
__QDISC_STATE_DEACTIVATED. Consequently any intermittent TX completion
can wake up the txq, resulting in calls to .ndo_start_xmit while the
data path is down. We have custom state checking to detect this case
and drop such packets.
- Because the IFF_UP flag doesn't reflect the interface's actual state
during a reset, we have custom state checking in .ndo_open and
.ndo_close to guard against invalid calls.
- Considering that the reset might take a considerable amount of time
(in particular if an IO fails and we end up waiting for its timeout), we
_do_ want NETDEV_GOING_DOWN and NETDEV_DOWN events so that components
like bonding, team, bridge, macvlan, vlan, ... can take appropriate
action.
Signed-off-by: Julian Wiedmann <jwi@linux.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2019-02-28 20:59:39 +03:00
|
|
|
static void qeth_l2_stop_card(struct qeth_card *card)
|
2008-02-15 11:19:42 +03:00
|
|
|
{
|
2019-06-11 19:37:55 +03:00
|
|
|
QETH_CARD_TEXT(card, 2, "stopcard");
|
2008-02-15 11:19:42 +03:00
|
|
|
|
|
|
|
qeth_set_allowed_threads(card, 0, 1);
|
2019-02-28 20:59:44 +03:00
|
|
|
|
2019-03-28 18:39:19 +03:00
|
|
|
cancel_work_sync(&card->rx_mode_work);
|
|
|
|
qeth_l2_drain_rx_mode_cache(card);
|
|
|
|
|
2008-02-15 11:19:42 +03:00
|
|
|
if (card->state == CARD_STATE_SOFTSETUP) {
|
|
|
|
qeth_clear_ipacmd_list(card);
|
2019-04-17 19:17:28 +03:00
|
|
|
qeth_drain_output_queues(card);
|
2020-03-10 20:38:03 +03:00
|
|
|
cancel_delayed_work_sync(&card->buffer_reclaim_work);
|
2008-02-15 11:19:42 +03:00
|
|
|
card->state = CARD_STATE_DOWN;
|
|
|
|
}
|
2019-02-04 19:40:09 +03:00
|
|
|
|
2019-12-23 17:03:21 +03:00
|
|
|
qeth_qdio_clear_card(card, 0);
|
2020-01-25 18:53:00 +03:00
|
|
|
qeth_clear_working_pool_list(card);
|
2019-02-04 19:40:09 +03:00
|
|
|
flush_workqueue(card->event_wq);
|
2019-12-18 18:32:27 +03:00
|
|
|
card->info.promisc_mode = 0;
|
2008-02-15 11:19:42 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static int qeth_l2_request_initial_mac(struct qeth_card *card)
|
|
|
|
{
|
|
|
|
int rc = 0;
|
|
|
|
|
2019-06-11 19:37:55 +03:00
|
|
|
QETH_CARD_TEXT(card, 2, "l2reqmac");
|
2008-02-15 11:19:42 +03:00
|
|
|
|
2017-06-20 17:00:34 +03:00
|
|
|
if (MACHINE_IS_VM) {
|
|
|
|
rc = qeth_vm_request_mac(card);
|
|
|
|
if (!rc)
|
|
|
|
goto out;
|
2018-11-02 21:04:08 +03:00
|
|
|
QETH_DBF_MESSAGE(2, "z/VM MAC Service failed on device %x: %#x\n",
|
|
|
|
CARD_DEVID(card), rc);
|
2019-06-11 19:37:55 +03:00
|
|
|
QETH_CARD_TEXT_(card, 2, "err%04x", rc);
|
2017-06-20 17:00:34 +03:00
|
|
|
/* fall back to alternative mechanism: */
|
|
|
|
}
|
|
|
|
|
2018-11-08 17:06:15 +03:00
|
|
|
if (!IS_OSN(card)) {
|
2008-02-15 11:19:42 +03:00
|
|
|
rc = qeth_setadpparms_change_macaddr(card);
|
s390/qeth: allow cmd callbacks to return errnos
Error propagation from cmd callbacks currently works in a way where
qeth_send_control_data_cb() picks the raw HW code from the response,
and the cmd's originator later translates this into an errno.
The callback itself only returns 0 ("done") or 1 ("expect more data").
This is
1. limiting, as the only means for the callback to report an internal
error is to invent pseudo HW codes (such as IPA_RC_ENOMEM), that
the originator then needs to understand. For non-IPA callbacks, we
even provide a separate field in the IO buffer metadata (iob->rc) so
the callback can pass back a return value.
2. fragile, as the originator must take care to not translate any errno
that is returned by qeth's own IO code paths (eg -ENOMEM). Also, any
originator that forgets to translate the HW codes potentially passes
garbage back to its caller. For instance, see
commit 2aa4867198c2 ("s390/qeth: translate SETVLAN/DELVLAN errors").
Introduce a new model where all HW error translation is done within the
callback, and the callback returns
> 0, if it expects more data (as before)
== 0, on success
< 0, with an errno
Start off with converting all callbacks to the new model that either
a) pass back pseudo HW codes, or b) have a dependency on a specific
HW error code. Also convert c) the one callback that uses iob->rc, and
d) qeth_setadpparms_change_macaddr_cb() so that it can pass back an
error back to qeth_l2_request_initial_mac() even when the cmd itself
was successful.
The old model remains supported: if the callback returns 0, we still
propagate the response's HW error code back to the originator.
Signed-off-by: Julian Wiedmann <jwi@linux.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2019-02-12 20:33:23 +03:00
|
|
|
if (!rc)
|
2018-04-26 10:42:24 +03:00
|
|
|
goto out;
|
2018-11-02 21:04:08 +03:00
|
|
|
QETH_DBF_MESSAGE(2, "READ_MAC Assist failed on device %x: %#x\n",
|
|
|
|
CARD_DEVID(card), rc);
|
2019-06-11 19:37:55 +03:00
|
|
|
QETH_CARD_TEXT_(card, 2, "1err%04x", rc);
|
2018-04-26 10:42:24 +03:00
|
|
|
/* fall back once more: */
|
2008-02-15 11:19:42 +03:00
|
|
|
}
|
2018-04-26 10:42:24 +03:00
|
|
|
|
|
|
|
/* some devices don't support a custom MAC address: */
|
2019-04-25 19:25:57 +03:00
|
|
|
if (IS_OSM(card) || IS_OSX(card))
|
2018-04-26 10:42:24 +03:00
|
|
|
return (rc) ? rc : -EADDRNOTAVAIL;
|
|
|
|
eth_hw_addr_random(card->dev);
|
|
|
|
|
2017-06-20 17:00:34 +03:00
|
|
|
out:
|
2019-06-11 19:37:55 +03:00
|
|
|
QETH_CARD_HEX(card, 2, card->dev->dev_addr, card->dev->addr_len);
|
2008-02-15 11:19:42 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-01-25 17:44:19 +03:00
|
|
|
static void qeth_l2_register_dev_addr(struct qeth_card *card)
|
|
|
|
{
|
|
|
|
if (!is_valid_ether_addr(card->dev->dev_addr))
|
|
|
|
qeth_l2_request_initial_mac(card);
|
|
|
|
|
|
|
|
if (!IS_OSN(card) && !qeth_l2_send_setmac(card, card->dev->dev_addr))
|
2020-03-25 12:35:02 +03:00
|
|
|
card->info.dev_addr_is_registered = 1;
|
|
|
|
else
|
|
|
|
card->info.dev_addr_is_registered = 0;
|
2019-01-25 17:44:19 +03:00
|
|
|
}
|
|
|
|
|
2019-01-25 17:44:18 +03:00
|
|
|
static int qeth_l2_validate_addr(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct qeth_card *card = dev->ml_priv;
|
|
|
|
|
2020-03-25 12:35:02 +03:00
|
|
|
if (card->info.dev_addr_is_registered)
|
2019-01-25 17:44:18 +03:00
|
|
|
return eth_validate_addr(dev);
|
|
|
|
|
|
|
|
QETH_CARD_TEXT(card, 4, "nomacadr");
|
|
|
|
return -EPERM;
|
|
|
|
}
|
|
|
|
|
2008-02-15 11:19:42 +03:00
|
|
|
static int qeth_l2_set_mac_address(struct net_device *dev, void *p)
|
|
|
|
{
|
|
|
|
struct sockaddr *addr = p;
|
2008-07-26 13:24:10 +04:00
|
|
|
struct qeth_card *card = dev->ml_priv;
|
2018-04-19 13:52:09 +03:00
|
|
|
u8 old_addr[ETH_ALEN];
|
2008-02-15 11:19:42 +03:00
|
|
|
int rc = 0;
|
|
|
|
|
2010-06-22 02:57:05 +04:00
|
|
|
QETH_CARD_TEXT(card, 3, "setmac");
|
2008-02-15 11:19:42 +03:00
|
|
|
|
2019-02-15 21:22:31 +03:00
|
|
|
if (IS_OSM(card) || IS_OSX(card)) {
|
2010-06-22 02:57:05 +04:00
|
|
|
QETH_CARD_TEXT(card, 3, "setmcTYP");
|
2008-02-15 11:19:42 +03:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
2017-12-20 22:11:01 +03:00
|
|
|
QETH_CARD_HEX(card, 3, addr->sa_data, ETH_ALEN);
|
2018-04-19 13:52:09 +03:00
|
|
|
if (!is_valid_ether_addr(addr->sa_data))
|
|
|
|
return -EADDRNOTAVAIL;
|
|
|
|
|
|
|
|
/* don't register the same address twice */
|
|
|
|
if (ether_addr_equal_64bits(dev->dev_addr, addr->sa_data) &&
|
2020-03-25 12:35:02 +03:00
|
|
|
card->info.dev_addr_is_registered)
|
2019-01-25 17:44:22 +03:00
|
|
|
return 0;
|
2018-04-19 13:52:09 +03:00
|
|
|
|
|
|
|
/* add the new address, switch over, drop the old */
|
|
|
|
rc = qeth_l2_send_setmac(card, addr->sa_data);
|
|
|
|
if (rc)
|
2019-01-25 17:44:22 +03:00
|
|
|
return rc;
|
2018-04-19 13:52:09 +03:00
|
|
|
ether_addr_copy(old_addr, dev->dev_addr);
|
|
|
|
ether_addr_copy(dev->dev_addr, addr->sa_data);
|
|
|
|
|
2020-03-25 12:35:02 +03:00
|
|
|
if (card->info.dev_addr_is_registered)
|
2018-04-19 13:52:09 +03:00
|
|
|
qeth_l2_remove_mac(card, old_addr);
|
2020-03-25 12:35:02 +03:00
|
|
|
card->info.dev_addr_is_registered = 1;
|
2019-01-25 17:44:22 +03:00
|
|
|
return 0;
|
2008-02-15 11:19:42 +03:00
|
|
|
}
|
|
|
|
|
2019-08-20 17:46:41 +03:00
|
|
|
static void qeth_l2_promisc_to_bridge(struct qeth_card *card, bool enable)
|
2015-05-18 15:27:55 +03:00
|
|
|
{
|
|
|
|
int role;
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
QETH_CARD_TEXT(card, 3, "pmisc2br");
|
|
|
|
|
2019-08-20 17:46:41 +03:00
|
|
|
if (enable) {
|
2015-05-18 15:27:55 +03:00
|
|
|
if (card->options.sbp.reflect_promisc_primary)
|
|
|
|
role = QETH_SBP_ROLE_PRIMARY;
|
|
|
|
else
|
|
|
|
role = QETH_SBP_ROLE_SECONDARY;
|
|
|
|
} else
|
|
|
|
role = QETH_SBP_ROLE_NONE;
|
|
|
|
|
|
|
|
rc = qeth_bridgeport_setrole(card, role);
|
2019-08-20 17:46:41 +03:00
|
|
|
QETH_CARD_TEXT_(card, 2, "bpm%c%04x", enable ? '+' : '-', rc);
|
2015-05-18 15:27:55 +03:00
|
|
|
if (!rc) {
|
|
|
|
card->options.sbp.role = role;
|
2019-08-20 17:46:41 +03:00
|
|
|
card->info.promisc_mode = enable;
|
2015-05-18 15:27:55 +03:00
|
|
|
}
|
2019-08-20 17:46:41 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void qeth_l2_set_promisc_mode(struct qeth_card *card)
|
|
|
|
{
|
|
|
|
bool enable = card->dev->flags & IFF_PROMISC;
|
2015-10-06 16:12:28 +03:00
|
|
|
|
2019-08-20 17:46:41 +03:00
|
|
|
if (card->info.promisc_mode == enable)
|
|
|
|
return;
|
|
|
|
|
2019-11-20 16:20:56 +03:00
|
|
|
if (qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE)) {
|
2019-08-20 17:46:41 +03:00
|
|
|
qeth_setadp_promisc_mode(card, enable);
|
2019-11-20 16:20:56 +03:00
|
|
|
} else {
|
|
|
|
mutex_lock(&card->sbp_lock);
|
|
|
|
if (card->options.sbp.reflect_promisc)
|
|
|
|
qeth_l2_promisc_to_bridge(card, enable);
|
|
|
|
mutex_unlock(&card->sbp_lock);
|
|
|
|
}
|
2015-10-06 16:12:28 +03:00
|
|
|
}
|
2019-08-20 17:46:41 +03:00
|
|
|
|
2015-10-06 16:12:28 +03:00
|
|
|
/* New MAC address is added to the hash table and marked to be written on card
|
|
|
|
* only if there is not in the hash table storage already
|
|
|
|
*
|
|
|
|
*/
|
2017-12-20 22:10:59 +03:00
|
|
|
static void qeth_l2_add_mac(struct qeth_card *card, struct netdev_hw_addr *ha)
|
2015-10-06 16:12:28 +03:00
|
|
|
{
|
2017-08-15 18:02:46 +03:00
|
|
|
u32 mac_hash = get_unaligned((u32 *)(&ha->addr[2]));
|
2015-10-06 16:12:28 +03:00
|
|
|
struct qeth_mac *mac;
|
|
|
|
|
2017-08-15 18:02:46 +03:00
|
|
|
hash_for_each_possible(card->mac_htable, mac, hnode, mac_hash) {
|
2017-12-20 22:11:01 +03:00
|
|
|
if (ether_addr_equal_64bits(ha->addr, mac->mac_addr)) {
|
2016-06-16 17:18:58 +03:00
|
|
|
mac->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
|
2015-10-06 16:12:28 +03:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
mac = kzalloc(sizeof(struct qeth_mac), GFP_ATOMIC);
|
|
|
|
if (!mac)
|
|
|
|
return;
|
|
|
|
|
2017-12-20 22:11:01 +03:00
|
|
|
ether_addr_copy(mac->mac_addr, ha->addr);
|
2016-06-16 17:18:58 +03:00
|
|
|
mac->disp_flag = QETH_DISP_ADDR_ADD;
|
2015-10-06 16:12:28 +03:00
|
|
|
|
2017-08-15 18:02:46 +03:00
|
|
|
hash_add(card->mac_htable, &mac->hnode, mac_hash);
|
2015-05-18 15:27:55 +03:00
|
|
|
}
|
|
|
|
|
2019-03-28 18:39:19 +03:00
|
|
|
static void qeth_l2_rx_mode_work(struct work_struct *work)
|
2008-02-15 11:19:42 +03:00
|
|
|
{
|
2019-03-28 18:39:19 +03:00
|
|
|
struct qeth_card *card = container_of(work, struct qeth_card,
|
|
|
|
rx_mode_work);
|
|
|
|
struct net_device *dev = card->dev;
|
2009-05-23 03:22:17 +04:00
|
|
|
struct netdev_hw_addr *ha;
|
2015-10-06 16:12:28 +03:00
|
|
|
struct qeth_mac *mac;
|
|
|
|
struct hlist_node *tmp;
|
|
|
|
int i;
|
|
|
|
int rc;
|
2008-02-15 11:19:42 +03:00
|
|
|
|
2010-06-22 02:57:05 +04:00
|
|
|
QETH_CARD_TEXT(card, 3, "setmulti");
|
2015-10-06 16:12:28 +03:00
|
|
|
|
2019-03-28 18:39:19 +03:00
|
|
|
netif_addr_lock_bh(dev);
|
2010-04-02 01:22:57 +04:00
|
|
|
netdev_for_each_mc_addr(ha, dev)
|
2017-12-20 22:10:59 +03:00
|
|
|
qeth_l2_add_mac(card, ha);
|
2010-01-26 00:36:10 +03:00
|
|
|
netdev_for_each_uc_addr(ha, dev)
|
2017-12-20 22:10:59 +03:00
|
|
|
qeth_l2_add_mac(card, ha);
|
2019-03-28 18:39:19 +03:00
|
|
|
netif_addr_unlock_bh(dev);
|
2015-10-06 16:12:28 +03:00
|
|
|
|
|
|
|
hash_for_each_safe(card->mac_htable, i, tmp, mac, hnode) {
|
2017-12-20 22:11:02 +03:00
|
|
|
switch (mac->disp_flag) {
|
|
|
|
case QETH_DISP_ADDR_DELETE:
|
2017-12-20 22:11:00 +03:00
|
|
|
qeth_l2_remove_mac(card, mac->mac_addr);
|
2015-10-06 16:12:28 +03:00
|
|
|
hash_del(&mac->hnode);
|
|
|
|
kfree(mac);
|
2017-12-20 22:11:02 +03:00
|
|
|
break;
|
|
|
|
case QETH_DISP_ADDR_ADD:
|
2017-12-20 22:11:00 +03:00
|
|
|
rc = qeth_l2_write_mac(card, mac->mac_addr);
|
2015-10-06 16:12:28 +03:00
|
|
|
if (rc) {
|
|
|
|
hash_del(&mac->hnode);
|
|
|
|
kfree(mac);
|
2017-12-20 22:11:02 +03:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* fall through */
|
|
|
|
default:
|
|
|
|
/* for next call to set_rx_mode(): */
|
2016-06-16 17:18:58 +03:00
|
|
|
mac->disp_flag = QETH_DISP_ADDR_DELETE;
|
2017-12-20 22:11:02 +03:00
|
|
|
}
|
2015-10-06 16:12:28 +03:00
|
|
|
}
|
2008-08-15 10:02:59 +04:00
|
|
|
|
2019-08-20 17:46:41 +03:00
|
|
|
qeth_l2_set_promisc_mode(card);
|
2008-02-15 11:19:42 +03:00
|
|
|
}
|
|
|
|
|
2017-08-18 11:19:04 +03:00
|
|
|
static int qeth_l2_xmit_osn(struct qeth_card *card, struct sk_buff *skb,
|
|
|
|
struct qeth_qdio_out_q *queue)
|
|
|
|
{
|
2020-03-18 15:54:46 +03:00
|
|
|
gfp_t gfp = GFP_ATOMIC | (skb_pfmemalloc(skb) ? __GFP_MEMALLOC : 0);
|
2018-09-17 18:36:04 +03:00
|
|
|
struct qeth_hdr *hdr = (struct qeth_hdr *)skb->data;
|
|
|
|
addr_t end = (addr_t)(skb->data + sizeof(*hdr));
|
|
|
|
addr_t start = (addr_t)skb->data;
|
|
|
|
unsigned int elements = 0;
|
|
|
|
unsigned int hd_len = 0;
|
|
|
|
int rc;
|
2017-08-18 11:19:04 +03:00
|
|
|
|
|
|
|
if (skb->protocol == htons(ETH_P_IPV6))
|
|
|
|
return -EPROTONOSUPPORT;
|
|
|
|
|
2018-09-17 18:36:04 +03:00
|
|
|
if (qeth_get_elements_for_range(start, end) > 1) {
|
|
|
|
/* Misaligned HW header, move it to its own buffer element. */
|
2020-03-18 15:54:46 +03:00
|
|
|
hdr = kmem_cache_alloc(qeth_core_header_cache, gfp);
|
2018-09-17 18:36:04 +03:00
|
|
|
if (!hdr)
|
|
|
|
return -ENOMEM;
|
|
|
|
hd_len = sizeof(*hdr);
|
|
|
|
skb_copy_from_linear_data(skb, (char *)hdr, hd_len);
|
|
|
|
elements++;
|
|
|
|
}
|
|
|
|
|
|
|
|
elements += qeth_count_elements(skb, hd_len);
|
2019-04-25 19:25:59 +03:00
|
|
|
if (elements > queue->max_elements) {
|
2018-09-17 18:36:04 +03:00
|
|
|
rc = -E2BIG;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
rc = qeth_do_send_packet(card, queue, skb, hdr, hd_len, hd_len,
|
|
|
|
elements);
|
|
|
|
out:
|
|
|
|
if (rc && hd_len)
|
|
|
|
kmem_cache_free(qeth_core_header_cache, hdr);
|
|
|
|
return rc;
|
2017-08-18 11:19:04 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static netdev_tx_t qeth_l2_hard_start_xmit(struct sk_buff *skb,
|
|
|
|
struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct qeth_card *card = dev->ml_priv;
|
2019-04-17 19:17:32 +03:00
|
|
|
u16 txq = skb_get_queue_mapping(skb);
|
2017-08-18 11:19:04 +03:00
|
|
|
struct qeth_qdio_out_q *queue;
|
|
|
|
int rc;
|
|
|
|
|
2019-08-23 12:48:49 +03:00
|
|
|
if (!skb_is_gso(skb))
|
|
|
|
qdisc_skb_cb(skb)->pkt_len = skb->len;
|
2019-04-17 19:17:32 +03:00
|
|
|
if (IS_IQD(card))
|
2019-04-17 19:17:35 +03:00
|
|
|
txq = qeth_iqd_translate_txq(dev, txq);
|
|
|
|
queue = card->qdio.out_qs[txq];
|
2017-08-18 11:19:04 +03:00
|
|
|
|
2018-07-19 13:43:58 +03:00
|
|
|
if (IS_OSN(card))
|
2017-08-18 11:19:04 +03:00
|
|
|
rc = qeth_l2_xmit_osn(card, skb, queue);
|
2018-07-19 13:43:58 +03:00
|
|
|
else
|
2019-04-17 19:17:33 +03:00
|
|
|
rc = qeth_xmit(card, skb, queue, qeth_get_ip_version(skb),
|
2019-04-25 19:26:00 +03:00
|
|
|
qeth_l2_fill_header);
|
2017-08-18 11:19:04 +03:00
|
|
|
|
2019-08-23 12:48:49 +03:00
|
|
|
if (!rc)
|
2017-08-18 11:19:04 +03:00
|
|
|
return NETDEV_TX_OK;
|
2008-02-15 11:19:42 +03:00
|
|
|
|
2019-02-15 21:22:29 +03:00
|
|
|
QETH_TXQ_STAT_INC(queue, tx_dropped);
|
2019-03-18 18:40:56 +03:00
|
|
|
kfree_skb(skb);
|
2008-02-15 11:19:42 +03:00
|
|
|
return NETDEV_TX_OK;
|
|
|
|
}
|
|
|
|
|
2019-04-17 19:17:32 +03:00
|
|
|
static u16 qeth_l2_select_queue(struct net_device *dev, struct sk_buff *skb,
|
|
|
|
struct net_device *sb_dev)
|
|
|
|
{
|
2019-04-17 19:17:33 +03:00
|
|
|
struct qeth_card *card = dev->ml_priv;
|
|
|
|
|
|
|
|
if (IS_IQD(card))
|
|
|
|
return qeth_iqd_select_queue(dev, skb,
|
2019-04-25 19:26:00 +03:00
|
|
|
qeth_get_ether_cast_type(skb),
|
2019-04-17 19:17:33 +03:00
|
|
|
sb_dev);
|
2020-03-18 15:54:47 +03:00
|
|
|
|
|
|
|
return IS_VM_NIC(card) ? netdev_pick_tx(dev, skb, sb_dev) :
|
|
|
|
qeth_get_priority_queue(card, skb);
|
2019-04-17 19:17:32 +03:00
|
|
|
}
|
|
|
|
|
2017-05-10 20:07:52 +03:00
|
|
|
static const struct device_type qeth_l2_devtype = {
|
|
|
|
.name = "qeth_layer2",
|
|
|
|
.groups = qeth_l2_attr_groups,
|
|
|
|
};
|
|
|
|
|
2008-02-15 11:19:42 +03:00
|
|
|
static int qeth_l2_probe_device(struct ccwgroup_device *gdev)
|
|
|
|
{
|
|
|
|
struct qeth_card *card = dev_get_drvdata(&gdev->dev);
|
2017-05-10 20:07:51 +03:00
|
|
|
int rc;
|
2008-02-15 11:19:42 +03:00
|
|
|
|
2020-03-27 13:19:34 +03:00
|
|
|
if (IS_OSN(card))
|
|
|
|
dev_notice(&gdev->dev, "OSN support will be dropped in 2021\n");
|
|
|
|
|
2019-03-18 18:40:54 +03:00
|
|
|
qeth_l2_vnicc_set_defaults(card);
|
2019-11-20 16:20:56 +03:00
|
|
|
mutex_init(&card->sbp_lock);
|
2019-03-18 18:40:54 +03:00
|
|
|
|
2017-05-10 20:07:52 +03:00
|
|
|
if (gdev->dev.type == &qeth_generic_devtype) {
|
|
|
|
rc = qeth_l2_create_device_attributes(&gdev->dev);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
}
|
2019-01-25 17:44:23 +03:00
|
|
|
|
2015-10-06 16:12:28 +03:00
|
|
|
hash_init(card->mac_htable);
|
2019-03-28 18:39:19 +03:00
|
|
|
INIT_WORK(&card->rx_mode_work, qeth_l2_rx_mode_work);
|
2008-02-15 11:19:42 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void qeth_l2_remove_device(struct ccwgroup_device *cgdev)
|
|
|
|
{
|
|
|
|
struct qeth_card *card = dev_get_drvdata(&cgdev->dev);
|
|
|
|
|
2017-05-10 20:07:52 +03:00
|
|
|
if (cgdev->dev.type == &qeth_generic_devtype)
|
|
|
|
qeth_l2_remove_device_attributes(&cgdev->dev);
|
2009-05-20 01:38:37 +04:00
|
|
|
qeth_set_allowed_threads(card, 0, 1);
|
2008-02-15 11:19:42 +03:00
|
|
|
wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);
|
|
|
|
|
2011-02-27 09:41:36 +03:00
|
|
|
if (cgdev->state == CCWGROUP_ONLINE)
|
2020-01-25 18:53:01 +03:00
|
|
|
qeth_set_offline(card, false);
|
2019-02-04 19:40:08 +03:00
|
|
|
|
|
|
|
cancel_work_sync(&card->close_dev_work);
|
2020-03-18 15:54:55 +03:00
|
|
|
if (card->dev->reg_state == NETREG_REGISTERED)
|
2018-11-02 21:04:10 +03:00
|
|
|
unregister_netdev(card->dev);
|
2008-02-15 11:19:42 +03:00
|
|
|
}
|
|
|
|
|
2019-03-28 18:39:19 +03:00
|
|
|
static void qeth_l2_set_rx_mode(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct qeth_card *card = dev->ml_priv;
|
|
|
|
|
|
|
|
schedule_work(&card->rx_mode_work);
|
|
|
|
}
|
|
|
|
|
2009-01-09 06:44:00 +03:00
|
|
|
static const struct net_device_ops qeth_l2_netdev_ops = {
|
2019-01-25 17:44:18 +03:00
|
|
|
.ndo_open = qeth_open,
|
|
|
|
.ndo_stop = qeth_stop,
|
2019-02-15 21:22:29 +03:00
|
|
|
.ndo_get_stats64 = qeth_get_stats64,
|
2009-01-08 21:50:55 +03:00
|
|
|
.ndo_start_xmit = qeth_l2_hard_start_xmit,
|
2017-12-01 12:14:50 +03:00
|
|
|
.ndo_features_check = qeth_features_check,
|
2019-04-17 19:17:32 +03:00
|
|
|
.ndo_select_queue = qeth_l2_select_queue,
|
2019-01-25 17:44:18 +03:00
|
|
|
.ndo_validate_addr = qeth_l2_validate_addr,
|
2015-10-06 16:12:28 +03:00
|
|
|
.ndo_set_rx_mode = qeth_l2_set_rx_mode,
|
2017-04-11 17:11:10 +03:00
|
|
|
.ndo_do_ioctl = qeth_do_ioctl,
|
2009-01-08 21:50:55 +03:00
|
|
|
.ndo_set_mac_address = qeth_l2_set_mac_address,
|
|
|
|
.ndo_vlan_rx_add_vid = qeth_l2_vlan_rx_add_vid,
|
|
|
|
.ndo_vlan_rx_kill_vid = qeth_l2_vlan_rx_kill_vid,
|
|
|
|
.ndo_tx_timeout = qeth_tx_timeout,
|
2016-06-16 17:18:59 +03:00
|
|
|
.ndo_fix_features = qeth_fix_features,
|
|
|
|
.ndo_set_features = qeth_set_features
|
2009-01-08 21:50:55 +03:00
|
|
|
};
|
|
|
|
|
2019-02-15 21:22:31 +03:00
|
|
|
static const struct net_device_ops qeth_osn_netdev_ops = {
|
|
|
|
.ndo_open = qeth_open,
|
|
|
|
.ndo_stop = qeth_stop,
|
|
|
|
.ndo_get_stats64 = qeth_get_stats64,
|
|
|
|
.ndo_start_xmit = qeth_l2_hard_start_xmit,
|
|
|
|
.ndo_validate_addr = eth_validate_addr,
|
|
|
|
.ndo_tx_timeout = qeth_tx_timeout,
|
|
|
|
};
|
|
|
|
|
2020-03-18 15:54:55 +03:00
|
|
|
static int qeth_l2_setup_netdev(struct qeth_card *card)
|
2008-02-15 11:19:42 +03:00
|
|
|
{
|
2018-07-19 13:43:51 +03:00
|
|
|
int rc;
|
2008-02-15 11:19:42 +03:00
|
|
|
|
2019-02-15 21:22:31 +03:00
|
|
|
if (IS_OSN(card)) {
|
|
|
|
card->dev->netdev_ops = &qeth_osn_netdev_ops;
|
2017-05-10 20:07:53 +03:00
|
|
|
card->dev->flags |= IFF_NOARP;
|
2019-02-15 21:22:31 +03:00
|
|
|
goto add_napi;
|
|
|
|
}
|
|
|
|
|
2020-03-18 15:54:47 +03:00
|
|
|
rc = qeth_setup_netdev(card);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
2019-02-15 21:22:31 +03:00
|
|
|
card->dev->needed_headroom = sizeof(struct qeth_hdr);
|
|
|
|
card->dev->netdev_ops = &qeth_l2_netdev_ops;
|
|
|
|
card->dev->priv_flags |= IFF_UNICAST_FLT;
|
2017-10-18 18:40:20 +03:00
|
|
|
|
2019-01-25 17:44:23 +03:00
|
|
|
if (IS_OSM(card)) {
|
2017-10-18 18:40:20 +03:00
|
|
|
card->dev->features |= NETIF_F_VLAN_CHALLENGED;
|
2019-01-25 17:44:23 +03:00
|
|
|
} else {
|
|
|
|
if (!IS_VM_NIC(card))
|
|
|
|
card->dev->hw_features |= NETIF_F_HW_VLAN_CTAG_FILTER;
|
2017-10-18 18:40:20 +03:00
|
|
|
card->dev->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
|
2019-01-25 17:44:23 +03:00
|
|
|
}
|
2018-03-09 20:12:54 +03:00
|
|
|
|
2019-04-25 19:25:57 +03:00
|
|
|
if (IS_OSD(card) && !IS_VM_NIC(card)) {
|
2017-12-01 12:14:50 +03:00
|
|
|
card->dev->features |= NETIF_F_SG;
|
2016-06-16 17:18:59 +03:00
|
|
|
/* OSA 3S and earlier has no RX/TX support */
|
2016-06-16 17:19:00 +03:00
|
|
|
if (qeth_is_supported(card, IPA_OUTBOUND_CHECKSUM)) {
|
2016-06-16 17:18:59 +03:00
|
|
|
card->dev->hw_features |= NETIF_F_IP_CSUM;
|
2016-06-16 17:19:00 +03:00
|
|
|
card->dev->vlan_features |= NETIF_F_IP_CSUM;
|
|
|
|
}
|
2015-09-18 17:06:51 +03:00
|
|
|
}
|
2018-04-26 10:42:22 +03:00
|
|
|
if (qeth_is_supported6(card, IPA_OUTBOUND_CHECKSUM_V6)) {
|
|
|
|
card->dev->hw_features |= NETIF_F_IPV6_CSUM;
|
|
|
|
card->dev->vlan_features |= NETIF_F_IPV6_CSUM;
|
|
|
|
}
|
2018-04-26 10:42:23 +03:00
|
|
|
if (qeth_is_supported(card, IPA_INBOUND_CHECKSUM) ||
|
|
|
|
qeth_is_supported6(card, IPA_INBOUND_CHECKSUM_V6)) {
|
|
|
|
card->dev->hw_features |= NETIF_F_RXCSUM;
|
|
|
|
card->dev->vlan_features |= NETIF_F_RXCSUM;
|
|
|
|
}
|
2018-10-12 18:27:15 +03:00
|
|
|
if (qeth_is_supported(card, IPA_OUTBOUND_TSO)) {
|
|
|
|
card->dev->hw_features |= NETIF_F_TSO;
|
|
|
|
card->dev->vlan_features |= NETIF_F_TSO;
|
|
|
|
}
|
|
|
|
if (qeth_is_supported6(card, IPA_OUTBOUND_TSO)) {
|
|
|
|
card->dev->hw_features |= NETIF_F_TSO6;
|
|
|
|
card->dev->vlan_features |= NETIF_F_TSO6;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (card->dev->hw_features & (NETIF_F_TSO | NETIF_F_TSO6)) {
|
|
|
|
card->dev->needed_headroom = sizeof(struct qeth_hdr_tso);
|
|
|
|
netif_set_gso_max_size(card->dev,
|
|
|
|
PAGE_SIZE * (QDIO_MAX_ELEMENTS_PER_BUFFER - 1));
|
|
|
|
}
|
2017-08-18 11:19:10 +03:00
|
|
|
|
2019-02-15 21:22:31 +03:00
|
|
|
add_napi:
|
2017-04-11 17:11:11 +03:00
|
|
|
netif_napi_add(card->dev, &card->napi, qeth_poll, QETH_NAPI_WEIGHT);
|
2020-03-18 15:54:55 +03:00
|
|
|
return register_netdev(card->dev);
|
2008-02-15 11:19:42 +03:00
|
|
|
}
|
|
|
|
|
2017-06-06 15:33:45 +03:00
|
|
|
static void qeth_l2_trace_features(struct qeth_card *card)
|
|
|
|
{
|
s390/qeth: add basic VNICC support
VNIC Characteristics (VNICC) are features of HiperSockets that define
how packets are handled by the underlying network hardware. For example,
if the VNICC flooding is configured on a qeth device, ethernet frames to
unknown destination MAC addresses are received.
Currently, there is support for seven VNICCs: flooding, multicast
flooding, receive broadcast, learning, takeover learning, takeover
setvmac, bridge invisible. Also, six IPA commands exist for configuring
VNICCs on a qeth device: query characteristics, query commands, enable
characteristic, disable characteristic, set timeout, get timeout.
This patch adds the basic code infrastructure for VNICC support to qeth.
It allows querying VNICC support from the underlying hardware. To this
end, it adds:
* basic message formats for IPA commands
* basic data structures
* basic error handling
* query characteristics IPA command support
The query characteristics IPA command allows requesting the currently
supported and currently enabled VNIC characteristics from the underlying
hardware.
Support for the other IPA commands and for the configuration of VNICCs
is added in follow-up patches together with the respective user
interface functions.
Signed-off-by: Hans Wippel <hwippel@linux.vnet.ibm.com>
Reviewed-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-09-18 22:18:14 +03:00
|
|
|
/* Set BridgePort features */
|
|
|
|
QETH_CARD_TEXT(card, 2, "featuSBP");
|
2017-06-06 15:33:45 +03:00
|
|
|
QETH_CARD_HEX(card, 2, &card->options.sbp.supported_funcs,
|
|
|
|
sizeof(card->options.sbp.supported_funcs));
|
s390/qeth: add basic VNICC support
VNIC Characteristics (VNICC) are features of HiperSockets that define
how packets are handled by the underlying network hardware. For example,
if the VNICC flooding is configured on a qeth device, ethernet frames to
unknown destination MAC addresses are received.
Currently, there is support for seven VNICCs: flooding, multicast
flooding, receive broadcast, learning, takeover learning, takeover
setvmac, bridge invisible. Also, six IPA commands exist for configuring
VNICCs on a qeth device: query characteristics, query commands, enable
characteristic, disable characteristic, set timeout, get timeout.
This patch adds the basic code infrastructure for VNICC support to qeth.
It allows querying VNICC support from the underlying hardware. To this
end, it adds:
* basic message formats for IPA commands
* basic data structures
* basic error handling
* query characteristics IPA command support
The query characteristics IPA command allows requesting the currently
supported and currently enabled VNIC characteristics from the underlying
hardware.
Support for the other IPA commands and for the configuration of VNICCs
is added in follow-up patches together with the respective user
interface functions.
Signed-off-by: Hans Wippel <hwippel@linux.vnet.ibm.com>
Reviewed-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-09-18 22:18:14 +03:00
|
|
|
/* VNIC Characteristics features */
|
|
|
|
QETH_CARD_TEXT(card, 2, "feaVNICC");
|
|
|
|
QETH_CARD_HEX(card, 2, &card->options.vnicc.sup_chars,
|
|
|
|
sizeof(card->options.vnicc.sup_chars));
|
2017-06-06 15:33:45 +03:00
|
|
|
}
|
|
|
|
|
2020-01-25 18:52:59 +03:00
|
|
|
static void qeth_l2_setup_bridgeport_attrs(struct qeth_card *card)
|
|
|
|
{
|
|
|
|
if (!card->options.sbp.reflect_promisc &&
|
|
|
|
card->options.sbp.role != QETH_SBP_ROLE_NONE) {
|
|
|
|
/* Conditional to avoid spurious error messages */
|
|
|
|
qeth_bridgeport_setrole(card, card->options.sbp.role);
|
|
|
|
/* Let the callback function refresh the stored role value. */
|
|
|
|
qeth_bridgeport_query_ports(card, &card->options.sbp.role,
|
|
|
|
NULL);
|
|
|
|
}
|
|
|
|
if (card->options.sbp.hostnotification) {
|
|
|
|
if (qeth_bridgeport_an_set(card, 1))
|
|
|
|
card->options.sbp.hostnotification = 0;
|
|
|
|
} else {
|
|
|
|
qeth_bridgeport_an_set(card, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-01-25 18:53:01 +03:00
|
|
|
static int qeth_l2_set_online(struct qeth_card *card)
|
2008-02-15 11:19:42 +03:00
|
|
|
{
|
2020-01-25 18:53:01 +03:00
|
|
|
struct ccwgroup_device *gdev = card->gdev;
|
2019-01-25 17:44:21 +03:00
|
|
|
struct net_device *dev = card->dev;
|
2008-02-15 11:19:42 +03:00
|
|
|
int rc = 0;
|
2018-11-02 21:04:11 +03:00
|
|
|
bool carrier_ok;
|
2008-02-15 11:19:42 +03:00
|
|
|
|
2018-11-02 21:04:11 +03:00
|
|
|
rc = qeth_core_hardsetup_card(card, &carrier_ok);
|
2008-02-15 11:19:42 +03:00
|
|
|
if (rc) {
|
2019-06-11 19:37:55 +03:00
|
|
|
QETH_CARD_TEXT_(card, 2, "2err%04x", rc);
|
2009-11-12 03:11:43 +03:00
|
|
|
rc = -ENODEV;
|
2008-02-15 11:19:42 +03:00
|
|
|
goto out_remove;
|
|
|
|
}
|
2019-01-25 17:44:19 +03:00
|
|
|
|
2019-11-20 16:20:56 +03:00
|
|
|
mutex_lock(&card->sbp_lock);
|
2019-02-28 20:59:37 +03:00
|
|
|
qeth_bridgeport_query_support(card);
|
2020-01-25 18:52:59 +03:00
|
|
|
if (card->options.sbp.supported_funcs) {
|
|
|
|
qeth_l2_setup_bridgeport_attrs(card);
|
2019-02-28 20:59:37 +03:00
|
|
|
dev_info(&card->gdev->dev,
|
2020-01-25 18:52:59 +03:00
|
|
|
"The device represents a Bridge Capable Port\n");
|
|
|
|
}
|
2019-11-20 16:20:56 +03:00
|
|
|
mutex_unlock(&card->sbp_lock);
|
2019-02-28 20:59:37 +03:00
|
|
|
|
|
|
|
qeth_l2_register_dev_addr(card);
|
|
|
|
|
s390/qeth: add basic VNICC support
VNIC Characteristics (VNICC) are features of HiperSockets that define
how packets are handled by the underlying network hardware. For example,
if the VNICC flooding is configured on a qeth device, ethernet frames to
unknown destination MAC addresses are received.
Currently, there is support for seven VNICCs: flooding, multicast
flooding, receive broadcast, learning, takeover learning, takeover
setvmac, bridge invisible. Also, six IPA commands exist for configuring
VNICCs on a qeth device: query characteristics, query commands, enable
characteristic, disable characteristic, set timeout, get timeout.
This patch adds the basic code infrastructure for VNICC support to qeth.
It allows querying VNICC support from the underlying hardware. To this
end, it adds:
* basic message formats for IPA commands
* basic data structures
* basic error handling
* query characteristics IPA command support
The query characteristics IPA command allows requesting the currently
supported and currently enabled VNIC characteristics from the underlying
hardware.
Support for the other IPA commands and for the configuration of VNICCs
is added in follow-up patches together with the respective user
interface functions.
Signed-off-by: Hans Wippel <hwippel@linux.vnet.ibm.com>
Reviewed-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-09-18 22:18:14 +03:00
|
|
|
/* for the rx_bcast characteristic, init VNICC after setmac */
|
|
|
|
qeth_l2_vnicc_init(card);
|
|
|
|
|
|
|
|
qeth_trace_features(card);
|
|
|
|
qeth_l2_trace_features(card);
|
|
|
|
|
2008-02-15 11:19:42 +03:00
|
|
|
qeth_print_status_message(card);
|
|
|
|
|
|
|
|
/* softsetup */
|
2019-06-11 19:37:55 +03:00
|
|
|
QETH_CARD_TEXT(card, 2, "softsetp");
|
2008-02-15 11:19:42 +03:00
|
|
|
|
|
|
|
card->state = CARD_STATE_SOFTSETUP;
|
|
|
|
|
|
|
|
qeth_set_allowed_threads(card, 0xffffffff, 0);
|
2018-06-29 20:45:54 +03:00
|
|
|
|
2020-03-18 15:54:55 +03:00
|
|
|
if (dev->reg_state != NETREG_REGISTERED) {
|
|
|
|
rc = qeth_l2_setup_netdev(card);
|
2019-01-25 17:44:21 +03:00
|
|
|
if (rc)
|
|
|
|
goto out_remove;
|
2020-03-18 15:54:55 +03:00
|
|
|
|
|
|
|
if (carrier_ok)
|
|
|
|
netif_carrier_on(dev);
|
2019-01-25 17:44:21 +03:00
|
|
|
} else {
|
|
|
|
rtnl_lock();
|
|
|
|
if (carrier_ok)
|
|
|
|
netif_carrier_on(dev);
|
|
|
|
else
|
|
|
|
netif_carrier_off(dev);
|
|
|
|
|
2019-01-25 17:44:22 +03:00
|
|
|
netif_device_attach(dev);
|
2019-01-25 17:44:21 +03:00
|
|
|
qeth_enable_hw_features(dev);
|
|
|
|
|
2019-02-28 20:59:36 +03:00
|
|
|
if (card->info.open_when_online) {
|
|
|
|
card->info.open_when_online = 0;
|
s390/qeth: call dev_close() during recovery
When resetting an interface ("recovery"), qeth currently attempts to
elide the call to dev_close(). We initially only call .ndo_close to
quiesce the data path, and then offline & online the ccwgroup device.
If the reset succeeded, a call to .ndo_open then resumes the data path
along with some internal setup (dev_addr validation, RX modeset) that
dev_open() would have usually triggered.
dev_close() only gets called (via the close_dev worker) if the reset
action fails.
It's unclear whether this was initially done due to locking concerns, or
rather to execute the reset transparently. Either way, temporarily
closing the interface without dev_close() is fragile, and means we're
susceptible to various races and unexpected behaviour. For instance:
- Bypassing dev_deactivate_many() means that the qdiscs are not set to
__QDISC_STATE_DEACTIVATED. Consequently any intermittent TX completion
can wake up the txq, resulting in calls to .ndo_start_xmit while the
data path is down. We have custom state checking to detect this case
and drop such packets.
- Because the IFF_UP flag doesn't reflect the interface's actual state
during a reset, we have custom state checking in .ndo_open and
.ndo_close to guard against invalid calls.
- Considering that the reset might take a considerable amount of time
(in particular if an IO fails and we end up waiting for its timeout), we
_do_ want NETDEV_GOING_DOWN and NETDEV_DOWN events so that components
like bonding, team, bridge, macvlan, vlan, ... can take appropriate
action.
Signed-off-by: Julian Wiedmann <jwi@linux.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2019-02-28 20:59:39 +03:00
|
|
|
dev_open(dev, NULL);
|
2008-02-15 11:19:42 +03:00
|
|
|
}
|
2019-01-25 17:44:21 +03:00
|
|
|
rtnl_unlock();
|
2008-02-15 11:19:42 +03:00
|
|
|
}
|
|
|
|
/* let user_space know that device is online */
|
|
|
|
kobject_uevent(&gdev->dev.kobj, KOBJ_CHANGE);
|
|
|
|
return 0;
|
2009-11-12 03:11:43 +03:00
|
|
|
|
2008-02-15 11:19:42 +03:00
|
|
|
out_remove:
|
s390/qeth: call dev_close() during recovery
When resetting an interface ("recovery"), qeth currently attempts to
elide the call to dev_close(). We initially only call .ndo_close to
quiesce the data path, and then offline & online the ccwgroup device.
If the reset succeeded, a call to .ndo_open then resumes the data path
along with some internal setup (dev_addr validation, RX modeset) that
dev_open() would have usually triggered.
dev_close() only gets called (via the close_dev worker) if the reset
action fails.
It's unclear whether this was initially done due to locking concerns, or
rather to execute the reset transparently. Either way, temporarily
closing the interface without dev_close() is fragile, and means we're
susceptible to various races and unexpected behaviour. For instance:
- Bypassing dev_deactivate_many() means that the qdiscs are not set to
__QDISC_STATE_DEACTIVATED. Consequently any intermittent TX completion
can wake up the txq, resulting in calls to .ndo_start_xmit while the
data path is down. We have custom state checking to detect this case
and drop such packets.
- Because the IFF_UP flag doesn't reflect the interface's actual state
during a reset, we have custom state checking in .ndo_open and
.ndo_close to guard against invalid calls.
- Considering that the reset might take a considerable amount of time
(in particular if an IO fails and we end up waiting for its timeout), we
_do_ want NETDEV_GOING_DOWN and NETDEV_DOWN events so that components
like bonding, team, bridge, macvlan, vlan, ... can take appropriate
action.
Signed-off-by: Julian Wiedmann <jwi@linux.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2019-02-28 20:59:39 +03:00
|
|
|
qeth_l2_stop_card(card);
|
2019-12-05 16:33:04 +03:00
|
|
|
qeth_stop_channel(&card->data);
|
|
|
|
qeth_stop_channel(&card->write);
|
|
|
|
qeth_stop_channel(&card->read);
|
2014-02-24 16:12:06 +04:00
|
|
|
qdio_free(CARD_DDEV(card));
|
2009-11-12 03:11:43 +03:00
|
|
|
return rc;
|
2008-02-15 11:19:42 +03:00
|
|
|
}
|
|
|
|
|
2020-01-25 18:53:01 +03:00
|
|
|
static void qeth_l2_set_offline(struct qeth_card *card)
|
2008-02-15 11:19:42 +03:00
|
|
|
{
|
s390/qeth: call dev_close() during recovery
When resetting an interface ("recovery"), qeth currently attempts to
elide the call to dev_close(). We initially only call .ndo_close to
quiesce the data path, and then offline & online the ccwgroup device.
If the reset succeeded, a call to .ndo_open then resumes the data path
along with some internal setup (dev_addr validation, RX modeset) that
dev_open() would have usually triggered.
dev_close() only gets called (via the close_dev worker) if the reset
action fails.
It's unclear whether this was initially done due to locking concerns, or
rather to execute the reset transparently. Either way, temporarily
closing the interface without dev_close() is fragile, and means we're
susceptible to various races and unexpected behaviour. For instance:
- Bypassing dev_deactivate_many() means that the qdiscs are not set to
__QDISC_STATE_DEACTIVATED. Consequently any intermittent TX completion
can wake up the txq, resulting in calls to .ndo_start_xmit while the
data path is down. We have custom state checking to detect this case
and drop such packets.
- Because the IFF_UP flag doesn't reflect the interface's actual state
during a reset, we have custom state checking in .ndo_open and
.ndo_close to guard against invalid calls.
- Considering that the reset might take a considerable amount of time
(in particular if an IO fails and we end up waiting for its timeout), we
_do_ want NETDEV_GOING_DOWN and NETDEV_DOWN events so that components
like bonding, team, bridge, macvlan, vlan, ... can take appropriate
action.
Signed-off-by: Julian Wiedmann <jwi@linux.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2019-02-28 20:59:39 +03:00
|
|
|
qeth_l2_stop_card(card);
|
2008-02-15 11:19:42 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static int __init qeth_l2_init(void)
|
|
|
|
{
|
2008-12-25 15:39:49 +03:00
|
|
|
pr_info("register layer 2 discipline\n");
|
2008-02-15 11:19:42 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit qeth_l2_exit(void)
|
|
|
|
{
|
2008-12-25 15:39:49 +03:00
|
|
|
pr_info("unregister layer 2 discipline\n");
|
2008-02-15 11:19:42 +03:00
|
|
|
}
|
|
|
|
|
2014-01-29 12:23:48 +04:00
|
|
|
/* Returns zero if the command is successfully "consumed" */
|
|
|
|
static int qeth_l2_control_event(struct qeth_card *card,
|
|
|
|
struct qeth_ipa_cmd *cmd)
|
|
|
|
{
|
|
|
|
switch (cmd->hdr.command) {
|
2015-05-18 15:27:56 +03:00
|
|
|
case IPA_CMD_SETBRIDGEPORT_OSA:
|
|
|
|
case IPA_CMD_SETBRIDGEPORT_IQD:
|
2014-01-29 12:23:48 +04:00
|
|
|
if (cmd->data.sbp.hdr.command_code ==
|
|
|
|
IPA_SBP_BRIDGE_PORT_STATE_CHANGE) {
|
|
|
|
qeth_bridge_state_change(card, cmd);
|
|
|
|
return 0;
|
|
|
|
} else
|
|
|
|
return 1;
|
|
|
|
case IPA_CMD_ADDRESS_CHANGE_NOTIF:
|
|
|
|
qeth_bridge_host_event(card, cmd);
|
|
|
|
return 0;
|
|
|
|
default:
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-05-15 20:02:21 +04:00
|
|
|
struct qeth_discipline qeth_l2_discipline = {
|
2017-05-10 20:07:52 +03:00
|
|
|
.devtype = &qeth_l2_devtype,
|
2012-05-15 20:02:21 +04:00
|
|
|
.setup = qeth_l2_probe_device,
|
2008-02-15 11:19:42 +03:00
|
|
|
.remove = qeth_l2_remove_device,
|
|
|
|
.set_online = qeth_l2_set_online,
|
|
|
|
.set_offline = qeth_l2_set_offline,
|
2017-04-11 17:11:10 +03:00
|
|
|
.do_ioctl = NULL,
|
2014-01-29 12:23:48 +04:00
|
|
|
.control_event_handler = qeth_l2_control_event,
|
2008-02-15 11:19:42 +03:00
|
|
|
};
|
2012-05-15 20:02:21 +04:00
|
|
|
EXPORT_SYMBOL_GPL(qeth_l2_discipline);
|
2008-02-15 11:19:42 +03:00
|
|
|
|
2020-03-27 13:19:33 +03:00
|
|
|
#ifdef CONFIG_QETH_OSN
|
2019-06-11 19:37:54 +03:00
|
|
|
static void qeth_osn_assist_cb(struct qeth_card *card,
|
2019-08-20 17:46:36 +03:00
|
|
|
struct qeth_cmd_buffer *iob,
|
|
|
|
unsigned int data_length)
|
2008-02-15 11:19:42 +03:00
|
|
|
{
|
2019-08-20 17:46:39 +03:00
|
|
|
qeth_notify_cmd(iob, 0);
|
2019-06-27 18:01:28 +03:00
|
|
|
qeth_put_cmd(iob);
|
2008-02-15 11:19:42 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
int qeth_osn_assist(struct net_device *dev, void *data, int data_len)
|
|
|
|
{
|
|
|
|
struct qeth_cmd_buffer *iob;
|
|
|
|
struct qeth_card *card;
|
|
|
|
|
2019-06-27 18:01:22 +03:00
|
|
|
if (data_len < 0)
|
|
|
|
return -EINVAL;
|
2008-02-15 11:19:42 +03:00
|
|
|
if (!dev)
|
|
|
|
return -ENODEV;
|
2008-07-26 13:24:10 +04:00
|
|
|
card = dev->ml_priv;
|
2008-02-15 11:19:42 +03:00
|
|
|
if (!card)
|
|
|
|
return -ENODEV;
|
2010-06-22 02:57:05 +04:00
|
|
|
QETH_CARD_TEXT(card, 2, "osnsdmc");
|
2015-01-16 16:05:47 +03:00
|
|
|
if (!qeth_card_hw_is_reachable(card))
|
2008-02-15 11:19:42 +03:00
|
|
|
return -ENODEV;
|
2019-06-27 18:01:22 +03:00
|
|
|
|
|
|
|
iob = qeth_alloc_cmd(&card->write, IPA_PDU_HEADER_SIZE + data_len, 1,
|
|
|
|
QETH_IPA_TIMEOUT);
|
2019-06-11 19:37:53 +03:00
|
|
|
if (!iob)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2020-01-25 18:53:02 +03:00
|
|
|
qeth_prepare_ipa_cmd(card, iob, (u16) data_len, NULL);
|
|
|
|
|
2018-03-09 20:12:52 +03:00
|
|
|
memcpy(__ipa_cmd(iob), data, data_len);
|
2019-06-11 19:37:54 +03:00
|
|
|
iob->callback = qeth_osn_assist_cb;
|
|
|
|
return qeth_send_ipa_cmd(card, iob, NULL, NULL);
|
2008-02-15 11:19:42 +03:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(qeth_osn_assist);
|
|
|
|
|
|
|
|
int qeth_osn_register(unsigned char *read_dev_no, struct net_device **dev,
|
|
|
|
int (*assist_cb)(struct net_device *, void *),
|
|
|
|
int (*data_cb)(struct sk_buff *))
|
|
|
|
{
|
|
|
|
struct qeth_card *card;
|
2018-11-08 17:06:18 +03:00
|
|
|
char bus_id[16];
|
|
|
|
u16 devno;
|
2008-02-15 11:19:42 +03:00
|
|
|
|
2018-11-08 17:06:18 +03:00
|
|
|
memcpy(&devno, read_dev_no, 2);
|
|
|
|
sprintf(bus_id, "0.0.%04x", devno);
|
|
|
|
card = qeth_get_card_by_busid(bus_id);
|
|
|
|
if (!card || !IS_OSN(card))
|
2008-02-15 11:19:42 +03:00
|
|
|
return -ENODEV;
|
2018-11-08 17:06:18 +03:00
|
|
|
*dev = card->dev;
|
|
|
|
|
2010-06-22 02:57:05 +04:00
|
|
|
QETH_CARD_TEXT(card, 2, "osnreg");
|
2008-02-15 11:19:42 +03:00
|
|
|
if ((assist_cb == NULL) || (data_cb == NULL))
|
|
|
|
return -EINVAL;
|
|
|
|
card->osn_info.assist_cb = assist_cb;
|
|
|
|
card->osn_info.data_cb = data_cb;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(qeth_osn_register);
|
|
|
|
|
|
|
|
void qeth_osn_deregister(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct qeth_card *card;
|
|
|
|
|
|
|
|
if (!dev)
|
|
|
|
return;
|
2008-07-26 13:24:10 +04:00
|
|
|
card = dev->ml_priv;
|
2008-02-15 11:19:42 +03:00
|
|
|
if (!card)
|
|
|
|
return;
|
2010-06-22 02:57:05 +04:00
|
|
|
QETH_CARD_TEXT(card, 2, "osndereg");
|
2008-02-15 11:19:42 +03:00
|
|
|
card->osn_info.assist_cb = NULL;
|
|
|
|
card->osn_info.data_cb = NULL;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(qeth_osn_deregister);
|
2020-03-27 13:19:33 +03:00
|
|
|
#endif
|
2008-02-15 11:19:42 +03:00
|
|
|
|
2014-01-14 18:54:11 +04:00
|
|
|
/* SETBRIDGEPORT support, async notifications */
|
|
|
|
|
2014-01-14 18:54:13 +04:00
|
|
|
enum qeth_an_event_type {anev_reg_unreg, anev_abort, anev_reset};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* qeth_bridge_emit_host_event() - bridgeport address change notification
|
|
|
|
* @card: qeth_card structure pointer, for udev events.
|
|
|
|
* @evtype: "normal" register/unregister, or abort, or reset. For abort
|
|
|
|
* and reset token and addr_lnid are unused and may be NULL.
|
|
|
|
* @code: event bitmask: high order bit 0x80 value 1 means removal of an
|
|
|
|
* object, 0 - addition of an object.
|
|
|
|
* 0x01 - VLAN, 0x02 - MAC, 0x03 - VLAN and MAC.
|
|
|
|
* @token: "network token" structure identifying physical address of the port.
|
|
|
|
* @addr_lnid: pointer to structure with MAC address and VLAN ID.
|
|
|
|
*
|
|
|
|
* This function is called when registrations and deregistrations are
|
|
|
|
* reported by the hardware, and also when notifications are enabled -
|
|
|
|
* for all currently registered addresses.
|
|
|
|
*/
|
|
|
|
static void qeth_bridge_emit_host_event(struct qeth_card *card,
|
|
|
|
enum qeth_an_event_type evtype,
|
|
|
|
u8 code, struct net_if_token *token, struct mac_addr_lnid *addr_lnid)
|
|
|
|
{
|
|
|
|
char str[7][32];
|
|
|
|
char *env[8];
|
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
switch (evtype) {
|
|
|
|
case anev_reg_unreg:
|
|
|
|
snprintf(str[i], sizeof(str[i]), "BRIDGEDHOST=%s",
|
|
|
|
(code & IPA_ADDR_CHANGE_CODE_REMOVAL)
|
|
|
|
? "deregister" : "register");
|
|
|
|
env[i] = str[i]; i++;
|
|
|
|
if (code & IPA_ADDR_CHANGE_CODE_VLANID) {
|
|
|
|
snprintf(str[i], sizeof(str[i]), "VLAN=%d",
|
|
|
|
addr_lnid->lnid);
|
|
|
|
env[i] = str[i]; i++;
|
|
|
|
}
|
|
|
|
if (code & IPA_ADDR_CHANGE_CODE_MACADDR) {
|
2015-09-18 17:06:48 +03:00
|
|
|
snprintf(str[i], sizeof(str[i]), "MAC=%pM",
|
2015-09-18 17:06:51 +03:00
|
|
|
addr_lnid->mac);
|
2014-01-14 18:54:13 +04:00
|
|
|
env[i] = str[i]; i++;
|
|
|
|
}
|
|
|
|
snprintf(str[i], sizeof(str[i]), "NTOK_BUSID=%x.%x.%04x",
|
|
|
|
token->cssid, token->ssid, token->devnum);
|
|
|
|
env[i] = str[i]; i++;
|
|
|
|
snprintf(str[i], sizeof(str[i]), "NTOK_IID=%02x", token->iid);
|
|
|
|
env[i] = str[i]; i++;
|
|
|
|
snprintf(str[i], sizeof(str[i]), "NTOK_CHPID=%02x",
|
|
|
|
token->chpid);
|
|
|
|
env[i] = str[i]; i++;
|
|
|
|
snprintf(str[i], sizeof(str[i]), "NTOK_CHID=%04x", token->chid);
|
|
|
|
env[i] = str[i]; i++;
|
|
|
|
break;
|
|
|
|
case anev_abort:
|
|
|
|
snprintf(str[i], sizeof(str[i]), "BRIDGEDHOST=abort");
|
|
|
|
env[i] = str[i]; i++;
|
|
|
|
break;
|
|
|
|
case anev_reset:
|
|
|
|
snprintf(str[i], sizeof(str[i]), "BRIDGEDHOST=reset");
|
|
|
|
env[i] = str[i]; i++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
env[i] = NULL;
|
|
|
|
kobject_uevent_env(&card->gdev->dev.kobj, KOBJ_CHANGE, env);
|
|
|
|
}
|
|
|
|
|
2014-01-14 18:54:11 +04:00
|
|
|
struct qeth_bridge_state_data {
|
|
|
|
struct work_struct worker;
|
|
|
|
struct qeth_card *card;
|
|
|
|
struct qeth_sbp_state_change qports;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void qeth_bridge_state_change_worker(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct qeth_bridge_state_data *data =
|
|
|
|
container_of(work, struct qeth_bridge_state_data, worker);
|
|
|
|
/* We are only interested in the first entry - local port */
|
|
|
|
struct qeth_sbp_port_entry *entry = &data->qports.entry[0];
|
|
|
|
char env_locrem[32];
|
|
|
|
char env_role[32];
|
|
|
|
char env_state[32];
|
|
|
|
char *env[] = {
|
|
|
|
env_locrem,
|
|
|
|
env_role,
|
|
|
|
env_state,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Role should not change by itself, but if it did, */
|
|
|
|
/* information from the hardware is authoritative. */
|
2019-11-20 16:20:56 +03:00
|
|
|
mutex_lock(&data->card->sbp_lock);
|
2014-01-14 18:54:11 +04:00
|
|
|
data->card->options.sbp.role = entry->role;
|
2019-11-20 16:20:56 +03:00
|
|
|
mutex_unlock(&data->card->sbp_lock);
|
2014-01-14 18:54:11 +04:00
|
|
|
|
|
|
|
snprintf(env_locrem, sizeof(env_locrem), "BRIDGEPORT=statechange");
|
|
|
|
snprintf(env_role, sizeof(env_role), "ROLE=%s",
|
|
|
|
(entry->role == QETH_SBP_ROLE_NONE) ? "none" :
|
|
|
|
(entry->role == QETH_SBP_ROLE_PRIMARY) ? "primary" :
|
|
|
|
(entry->role == QETH_SBP_ROLE_SECONDARY) ? "secondary" :
|
|
|
|
"<INVALID>");
|
|
|
|
snprintf(env_state, sizeof(env_state), "STATE=%s",
|
|
|
|
(entry->state == QETH_SBP_STATE_INACTIVE) ? "inactive" :
|
|
|
|
(entry->state == QETH_SBP_STATE_STANDBY) ? "standby" :
|
|
|
|
(entry->state == QETH_SBP_STATE_ACTIVE) ? "active" :
|
|
|
|
"<INVALID>");
|
|
|
|
kobject_uevent_env(&data->card->gdev->dev.kobj,
|
|
|
|
KOBJ_CHANGE, env);
|
|
|
|
kfree(data);
|
|
|
|
}
|
|
|
|
|
2014-01-29 12:23:48 +04:00
|
|
|
static void qeth_bridge_state_change(struct qeth_card *card,
|
|
|
|
struct qeth_ipa_cmd *cmd)
|
2014-01-14 18:54:11 +04:00
|
|
|
{
|
|
|
|
struct qeth_sbp_state_change *qports =
|
|
|
|
&cmd->data.sbp.data.state_change;
|
|
|
|
struct qeth_bridge_state_data *data;
|
|
|
|
int extrasize;
|
|
|
|
|
|
|
|
QETH_CARD_TEXT(card, 2, "brstchng");
|
|
|
|
if (qports->entry_length != sizeof(struct qeth_sbp_port_entry)) {
|
2014-10-22 14:18:03 +04:00
|
|
|
QETH_CARD_TEXT_(card, 2, "BPsz%04x", qports->entry_length);
|
2014-01-14 18:54:11 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
extrasize = sizeof(struct qeth_sbp_port_entry) * qports->num_entries;
|
|
|
|
data = kzalloc(sizeof(struct qeth_bridge_state_data) + extrasize,
|
|
|
|
GFP_ATOMIC);
|
|
|
|
if (!data) {
|
|
|
|
QETH_CARD_TEXT(card, 2, "BPSalloc");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
INIT_WORK(&data->worker, qeth_bridge_state_change_worker);
|
|
|
|
data->card = card;
|
|
|
|
memcpy(&data->qports, qports,
|
|
|
|
sizeof(struct qeth_sbp_state_change) + extrasize);
|
2019-02-04 19:40:09 +03:00
|
|
|
queue_work(card->event_wq, &data->worker);
|
2014-01-14 18:54:11 +04:00
|
|
|
}
|
|
|
|
|
2014-01-14 18:54:13 +04:00
|
|
|
struct qeth_bridge_host_data {
|
|
|
|
struct work_struct worker;
|
|
|
|
struct qeth_card *card;
|
|
|
|
struct qeth_ipacmd_addr_change hostevs;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void qeth_bridge_host_event_worker(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct qeth_bridge_host_data *data =
|
|
|
|
container_of(work, struct qeth_bridge_host_data, worker);
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (data->hostevs.lost_event_mask) {
|
|
|
|
dev_info(&data->card->gdev->dev,
|
2015-05-18 15:27:56 +03:00
|
|
|
"Address notification from the Bridge Port stopped %s (%s)\n",
|
2014-01-14 18:54:13 +04:00
|
|
|
data->card->dev->name,
|
|
|
|
(data->hostevs.lost_event_mask == 0x01)
|
|
|
|
? "Overflow"
|
|
|
|
: (data->hostevs.lost_event_mask == 0x02)
|
|
|
|
? "Bridge port state change"
|
|
|
|
: "Unknown reason");
|
2019-11-20 16:20:56 +03:00
|
|
|
mutex_lock(&data->card->sbp_lock);
|
2014-01-14 18:54:13 +04:00
|
|
|
data->card->options.sbp.hostnotification = 0;
|
2019-11-20 16:20:56 +03:00
|
|
|
mutex_unlock(&data->card->sbp_lock);
|
2014-01-14 18:54:13 +04:00
|
|
|
qeth_bridge_emit_host_event(data->card, anev_abort,
|
|
|
|
0, NULL, NULL);
|
|
|
|
} else
|
|
|
|
for (i = 0; i < data->hostevs.num_entries; i++) {
|
|
|
|
struct qeth_ipacmd_addr_change_entry *entry =
|
|
|
|
&data->hostevs.entry[i];
|
|
|
|
qeth_bridge_emit_host_event(data->card,
|
|
|
|
anev_reg_unreg,
|
|
|
|
entry->change_code,
|
|
|
|
&entry->token, &entry->addr_lnid);
|
|
|
|
}
|
|
|
|
kfree(data);
|
|
|
|
}
|
|
|
|
|
2014-01-29 12:23:48 +04:00
|
|
|
static void qeth_bridge_host_event(struct qeth_card *card,
|
|
|
|
struct qeth_ipa_cmd *cmd)
|
2014-01-14 18:54:13 +04:00
|
|
|
{
|
|
|
|
struct qeth_ipacmd_addr_change *hostevs =
|
|
|
|
&cmd->data.addrchange;
|
|
|
|
struct qeth_bridge_host_data *data;
|
|
|
|
int extrasize;
|
|
|
|
|
|
|
|
QETH_CARD_TEXT(card, 2, "brhostev");
|
|
|
|
if (cmd->hdr.return_code != 0x0000) {
|
|
|
|
if (cmd->hdr.return_code == 0x0010) {
|
|
|
|
if (hostevs->lost_event_mask == 0x00)
|
|
|
|
hostevs->lost_event_mask = 0xff;
|
|
|
|
} else {
|
|
|
|
QETH_CARD_TEXT_(card, 2, "BPHe%04x",
|
|
|
|
cmd->hdr.return_code);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
extrasize = sizeof(struct qeth_ipacmd_addr_change_entry) *
|
|
|
|
hostevs->num_entries;
|
|
|
|
data = kzalloc(sizeof(struct qeth_bridge_host_data) + extrasize,
|
|
|
|
GFP_ATOMIC);
|
|
|
|
if (!data) {
|
|
|
|
QETH_CARD_TEXT(card, 2, "BPHalloc");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
INIT_WORK(&data->worker, qeth_bridge_host_event_worker);
|
|
|
|
data->card = card;
|
|
|
|
memcpy(&data->hostevs, hostevs,
|
|
|
|
sizeof(struct qeth_ipacmd_addr_change) + extrasize);
|
2019-02-04 19:40:09 +03:00
|
|
|
queue_work(card->event_wq, &data->worker);
|
2014-01-14 18:54:13 +04:00
|
|
|
}
|
|
|
|
|
2014-01-14 18:54:11 +04:00
|
|
|
/* SETBRIDGEPORT support; sending commands */
|
|
|
|
|
|
|
|
struct _qeth_sbp_cbctl {
|
|
|
|
union {
|
|
|
|
u32 supported;
|
|
|
|
struct {
|
|
|
|
enum qeth_sbp_roles *role;
|
|
|
|
enum qeth_sbp_states *state;
|
|
|
|
} qports;
|
|
|
|
} data;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int qeth_bridgeport_makerc(struct qeth_card *card,
|
2019-02-12 20:33:24 +03:00
|
|
|
struct qeth_ipa_cmd *cmd)
|
2014-01-14 18:54:11 +04:00
|
|
|
{
|
2019-02-12 20:33:24 +03:00
|
|
|
struct qeth_ipacmd_setbridgeport *sbp = &cmd->data.sbp;
|
|
|
|
enum qeth_ipa_sbp_cmd setcmd = sbp->hdr.command_code;
|
|
|
|
u16 ipa_rc = cmd->hdr.return_code;
|
|
|
|
u16 sbp_rc = sbp->hdr.return_code;
|
2014-01-14 18:54:11 +04:00
|
|
|
int rc;
|
|
|
|
|
2019-02-12 20:33:24 +03:00
|
|
|
if (ipa_rc == IPA_RC_SUCCESS && sbp_rc == IPA_RC_SUCCESS)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if ((IS_IQD(card) && ipa_rc == IPA_RC_SUCCESS) ||
|
|
|
|
(!IS_IQD(card) && ipa_rc == sbp_rc)) {
|
|
|
|
switch (sbp_rc) {
|
2017-06-20 17:00:31 +03:00
|
|
|
case IPA_RC_SUCCESS:
|
2014-01-14 18:54:11 +04:00
|
|
|
rc = 0;
|
|
|
|
break;
|
2017-06-20 17:00:31 +03:00
|
|
|
case IPA_RC_L2_UNSUPPORTED_CMD:
|
|
|
|
case IPA_RC_UNSUPPORTED_COMMAND:
|
2015-05-18 15:27:58 +03:00
|
|
|
rc = -EOPNOTSUPP;
|
2014-01-14 18:54:11 +04:00
|
|
|
break;
|
2017-06-20 17:00:31 +03:00
|
|
|
case IPA_RC_SBP_OSA_NOT_CONFIGURED:
|
|
|
|
case IPA_RC_SBP_IQD_NOT_CONFIGURED:
|
2014-01-14 18:54:11 +04:00
|
|
|
rc = -ENODEV; /* maybe not the best code here? */
|
|
|
|
dev_err(&card->gdev->dev,
|
2015-05-18 15:27:56 +03:00
|
|
|
"The device is not configured as a Bridge Port\n");
|
2014-01-14 18:54:11 +04:00
|
|
|
break;
|
2017-06-20 17:00:31 +03:00
|
|
|
case IPA_RC_SBP_OSA_OS_MISMATCH:
|
|
|
|
case IPA_RC_SBP_IQD_OS_MISMATCH:
|
2016-06-16 17:18:51 +03:00
|
|
|
rc = -EPERM;
|
|
|
|
dev_err(&card->gdev->dev,
|
|
|
|
"A Bridge Port is already configured by a different operating system\n");
|
|
|
|
break;
|
2017-06-20 17:00:31 +03:00
|
|
|
case IPA_RC_SBP_OSA_ANO_DEV_PRIMARY:
|
|
|
|
case IPA_RC_SBP_IQD_ANO_DEV_PRIMARY:
|
2014-01-14 18:54:11 +04:00
|
|
|
switch (setcmd) {
|
|
|
|
case IPA_SBP_SET_PRIMARY_BRIDGE_PORT:
|
|
|
|
rc = -EEXIST;
|
|
|
|
dev_err(&card->gdev->dev,
|
2015-05-18 15:27:56 +03:00
|
|
|
"The LAN already has a primary Bridge Port\n");
|
2014-01-14 18:54:11 +04:00
|
|
|
break;
|
|
|
|
case IPA_SBP_SET_SECONDARY_BRIDGE_PORT:
|
|
|
|
rc = -EBUSY;
|
|
|
|
dev_err(&card->gdev->dev,
|
2015-05-18 15:27:56 +03:00
|
|
|
"The device is already a primary Bridge Port\n");
|
2014-01-14 18:54:11 +04:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
rc = -EIO;
|
|
|
|
}
|
|
|
|
break;
|
2017-06-20 17:00:31 +03:00
|
|
|
case IPA_RC_SBP_OSA_CURRENT_SECOND:
|
|
|
|
case IPA_RC_SBP_IQD_CURRENT_SECOND:
|
2014-01-14 18:54:11 +04:00
|
|
|
rc = -EBUSY;
|
|
|
|
dev_err(&card->gdev->dev,
|
2015-05-18 15:27:56 +03:00
|
|
|
"The device is already a secondary Bridge Port\n");
|
2014-01-14 18:54:11 +04:00
|
|
|
break;
|
2017-06-20 17:00:31 +03:00
|
|
|
case IPA_RC_SBP_OSA_LIMIT_SECOND:
|
|
|
|
case IPA_RC_SBP_IQD_LIMIT_SECOND:
|
2014-01-14 18:54:11 +04:00
|
|
|
rc = -EEXIST;
|
|
|
|
dev_err(&card->gdev->dev,
|
2015-05-18 15:27:56 +03:00
|
|
|
"The LAN cannot have more secondary Bridge Ports\n");
|
2014-01-14 18:54:11 +04:00
|
|
|
break;
|
2017-06-20 17:00:31 +03:00
|
|
|
case IPA_RC_SBP_OSA_CURRENT_PRIMARY:
|
|
|
|
case IPA_RC_SBP_IQD_CURRENT_PRIMARY:
|
2014-01-14 18:54:11 +04:00
|
|
|
rc = -EBUSY;
|
|
|
|
dev_err(&card->gdev->dev,
|
2015-05-18 15:27:56 +03:00
|
|
|
"The device is already a primary Bridge Port\n");
|
2014-01-14 18:54:11 +04:00
|
|
|
break;
|
2017-06-20 17:00:31 +03:00
|
|
|
case IPA_RC_SBP_OSA_NOT_AUTHD_BY_ZMAN:
|
|
|
|
case IPA_RC_SBP_IQD_NOT_AUTHD_BY_ZMAN:
|
2014-01-14 18:54:11 +04:00
|
|
|
rc = -EACCES;
|
|
|
|
dev_err(&card->gdev->dev,
|
2015-05-18 15:27:56 +03:00
|
|
|
"The device is not authorized to be a Bridge Port\n");
|
2014-01-14 18:54:11 +04:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
rc = -EIO;
|
|
|
|
}
|
2019-02-12 20:33:24 +03:00
|
|
|
} else {
|
|
|
|
switch (ipa_rc) {
|
2015-05-18 15:27:56 +03:00
|
|
|
case IPA_RC_NOTSUPP:
|
2015-05-18 15:27:58 +03:00
|
|
|
rc = -EOPNOTSUPP;
|
2015-05-18 15:27:56 +03:00
|
|
|
break;
|
|
|
|
case IPA_RC_UNSUPPORTED_COMMAND:
|
2015-05-18 15:27:58 +03:00
|
|
|
rc = -EOPNOTSUPP;
|
2015-05-18 15:27:56 +03:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
rc = -EIO;
|
|
|
|
}
|
2019-02-12 20:33:24 +03:00
|
|
|
}
|
2015-05-18 15:27:56 +03:00
|
|
|
|
2014-01-14 18:54:11 +04:00
|
|
|
if (rc) {
|
2019-02-12 20:33:24 +03:00
|
|
|
QETH_CARD_TEXT_(card, 2, "SBPi%04x", ipa_rc);
|
|
|
|
QETH_CARD_TEXT_(card, 2, "SBPc%04x", sbp_rc);
|
2014-01-14 18:54:11 +04:00
|
|
|
}
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2017-08-15 18:02:47 +03:00
|
|
|
static struct qeth_cmd_buffer *qeth_sbp_build_cmd(struct qeth_card *card,
|
|
|
|
enum qeth_ipa_sbp_cmd sbp_cmd,
|
2019-06-27 18:01:24 +03:00
|
|
|
unsigned int data_length)
|
2015-05-18 15:27:56 +03:00
|
|
|
{
|
2019-04-25 19:25:57 +03:00
|
|
|
enum qeth_ipa_cmds ipa_cmd = IS_IQD(card) ? IPA_CMD_SETBRIDGEPORT_IQD :
|
|
|
|
IPA_CMD_SETBRIDGEPORT_OSA;
|
2019-06-27 18:01:24 +03:00
|
|
|
struct qeth_ipacmd_sbp_hdr *hdr;
|
2017-08-15 18:02:47 +03:00
|
|
|
struct qeth_cmd_buffer *iob;
|
|
|
|
|
2019-06-27 18:01:24 +03:00
|
|
|
iob = qeth_ipa_alloc_cmd(card, ipa_cmd, QETH_PROT_NONE,
|
|
|
|
data_length +
|
|
|
|
offsetof(struct qeth_ipacmd_setbridgeport,
|
|
|
|
data));
|
2017-08-15 18:02:47 +03:00
|
|
|
if (!iob)
|
|
|
|
return iob;
|
2019-06-27 18:01:24 +03:00
|
|
|
|
|
|
|
hdr = &__ipa_cmd(iob)->data.sbp.hdr;
|
|
|
|
hdr->cmdlength = sizeof(*hdr) + data_length;
|
|
|
|
hdr->command_code = sbp_cmd;
|
|
|
|
hdr->used_total = 1;
|
|
|
|
hdr->seq_no = 1;
|
2017-08-15 18:02:47 +03:00
|
|
|
return iob;
|
2015-05-18 15:27:56 +03:00
|
|
|
}
|
|
|
|
|
2014-01-14 18:54:11 +04:00
|
|
|
static int qeth_bridgeport_query_support_cb(struct qeth_card *card,
|
|
|
|
struct qeth_reply *reply, unsigned long data)
|
|
|
|
{
|
|
|
|
struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
|
|
|
|
struct _qeth_sbp_cbctl *cbctl = (struct _qeth_sbp_cbctl *)reply->param;
|
2019-02-12 20:33:24 +03:00
|
|
|
int rc;
|
|
|
|
|
2014-01-14 18:54:11 +04:00
|
|
|
QETH_CARD_TEXT(card, 2, "brqsupcb");
|
2019-02-12 20:33:24 +03:00
|
|
|
rc = qeth_bridgeport_makerc(card, cmd);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
cbctl->data.supported =
|
|
|
|
cmd->data.sbp.data.query_cmds_supp.supported_cmds;
|
2014-01-14 18:54:11 +04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* qeth_bridgeport_query_support() - store bitmask of supported subfunctions.
|
|
|
|
* @card: qeth_card structure pointer.
|
|
|
|
*
|
|
|
|
* Sets bitmask of supported setbridgeport subfunctions in the qeth_card
|
|
|
|
* strucutre: card->options.sbp.supported_funcs.
|
|
|
|
*/
|
2014-01-29 12:23:48 +04:00
|
|
|
static void qeth_bridgeport_query_support(struct qeth_card *card)
|
2014-01-14 18:54:11 +04:00
|
|
|
{
|
|
|
|
struct qeth_cmd_buffer *iob;
|
|
|
|
struct _qeth_sbp_cbctl cbctl;
|
|
|
|
|
|
|
|
QETH_CARD_TEXT(card, 2, "brqsuppo");
|
2017-08-15 18:02:47 +03:00
|
|
|
iob = qeth_sbp_build_cmd(card, IPA_SBP_QUERY_COMMANDS_SUPPORTED,
|
2019-06-27 18:01:24 +03:00
|
|
|
SBP_DATA_SIZEOF(query_cmds_supp));
|
2015-01-21 15:39:10 +03:00
|
|
|
if (!iob)
|
|
|
|
return;
|
2019-02-12 20:33:24 +03:00
|
|
|
|
2014-01-14 18:54:11 +04:00
|
|
|
if (qeth_send_ipa_cmd(card, iob, qeth_bridgeport_query_support_cb,
|
2019-02-12 20:33:24 +03:00
|
|
|
&cbctl)) {
|
2014-01-14 18:54:11 +04:00
|
|
|
card->options.sbp.role = QETH_SBP_ROLE_NONE;
|
2019-02-12 20:33:24 +03:00
|
|
|
card->options.sbp.supported_funcs = 0;
|
2014-01-14 18:54:11 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
card->options.sbp.supported_funcs = cbctl.data.supported;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int qeth_bridgeport_query_ports_cb(struct qeth_card *card,
|
|
|
|
struct qeth_reply *reply, unsigned long data)
|
|
|
|
{
|
|
|
|
struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
|
|
|
|
struct qeth_sbp_query_ports *qports = &cmd->data.sbp.data.query_ports;
|
|
|
|
struct _qeth_sbp_cbctl *cbctl = (struct _qeth_sbp_cbctl *)reply->param;
|
2019-02-12 20:33:24 +03:00
|
|
|
int rc;
|
2014-01-14 18:54:11 +04:00
|
|
|
|
|
|
|
QETH_CARD_TEXT(card, 2, "brqprtcb");
|
2019-02-12 20:33:24 +03:00
|
|
|
rc = qeth_bridgeport_makerc(card, cmd);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
2014-01-14 18:54:11 +04:00
|
|
|
if (qports->entry_length != sizeof(struct qeth_sbp_port_entry)) {
|
|
|
|
QETH_CARD_TEXT_(card, 2, "SBPs%04x", qports->entry_length);
|
2019-02-12 20:33:24 +03:00
|
|
|
return -EINVAL;
|
2014-01-14 18:54:11 +04:00
|
|
|
}
|
|
|
|
/* first entry contains the state of the local port */
|
|
|
|
if (qports->num_entries > 0) {
|
|
|
|
if (cbctl->data.qports.role)
|
|
|
|
*cbctl->data.qports.role = qports->entry[0].role;
|
|
|
|
if (cbctl->data.qports.state)
|
|
|
|
*cbctl->data.qports.state = qports->entry[0].state;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* qeth_bridgeport_query_ports() - query local bridgeport status.
|
|
|
|
* @card: qeth_card structure pointer.
|
|
|
|
* @role: Role of the port: 0-none, 1-primary, 2-secondary.
|
|
|
|
* @state: State of the port: 0-inactive, 1-standby, 2-active.
|
|
|
|
*
|
|
|
|
* Returns negative errno-compatible error indication or 0 on success.
|
|
|
|
*
|
|
|
|
* 'role' and 'state' are not updated in case of hardware operation failure.
|
|
|
|
*/
|
|
|
|
int qeth_bridgeport_query_ports(struct qeth_card *card,
|
|
|
|
enum qeth_sbp_roles *role, enum qeth_sbp_states *state)
|
|
|
|
{
|
|
|
|
struct qeth_cmd_buffer *iob;
|
|
|
|
struct _qeth_sbp_cbctl cbctl = {
|
|
|
|
.data = {
|
|
|
|
.qports = {
|
|
|
|
.role = role,
|
|
|
|
.state = state,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
QETH_CARD_TEXT(card, 2, "brqports");
|
|
|
|
if (!(card->options.sbp.supported_funcs & IPA_SBP_QUERY_BRIDGE_PORTS))
|
|
|
|
return -EOPNOTSUPP;
|
2017-08-15 18:02:47 +03:00
|
|
|
iob = qeth_sbp_build_cmd(card, IPA_SBP_QUERY_BRIDGE_PORTS, 0);
|
2015-01-21 15:39:10 +03:00
|
|
|
if (!iob)
|
|
|
|
return -ENOMEM;
|
2019-02-12 20:33:24 +03:00
|
|
|
|
|
|
|
return qeth_send_ipa_cmd(card, iob, qeth_bridgeport_query_ports_cb,
|
|
|
|
&cbctl);
|
2014-01-14 18:54:11 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static int qeth_bridgeport_set_cb(struct qeth_card *card,
|
|
|
|
struct qeth_reply *reply, unsigned long data)
|
|
|
|
{
|
|
|
|
struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *)data;
|
2019-02-12 20:33:24 +03:00
|
|
|
|
2014-01-14 18:54:11 +04:00
|
|
|
QETH_CARD_TEXT(card, 2, "brsetrcb");
|
2019-02-12 20:33:24 +03:00
|
|
|
return qeth_bridgeport_makerc(card, cmd);
|
2014-01-14 18:54:11 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* qeth_bridgeport_setrole() - Assign primary role to the port.
|
|
|
|
* @card: qeth_card structure pointer.
|
|
|
|
* @role: Role to assign.
|
|
|
|
*
|
|
|
|
* Returns negative errno-compatible error indication or 0 on success.
|
|
|
|
*/
|
|
|
|
int qeth_bridgeport_setrole(struct qeth_card *card, enum qeth_sbp_roles role)
|
|
|
|
{
|
|
|
|
struct qeth_cmd_buffer *iob;
|
|
|
|
enum qeth_ipa_sbp_cmd setcmd;
|
2019-06-27 18:01:24 +03:00
|
|
|
unsigned int cmdlength = 0;
|
2014-01-14 18:54:11 +04:00
|
|
|
|
|
|
|
QETH_CARD_TEXT(card, 2, "brsetrol");
|
|
|
|
switch (role) {
|
|
|
|
case QETH_SBP_ROLE_NONE:
|
|
|
|
setcmd = IPA_SBP_RESET_BRIDGE_PORT_ROLE;
|
|
|
|
break;
|
|
|
|
case QETH_SBP_ROLE_PRIMARY:
|
|
|
|
setcmd = IPA_SBP_SET_PRIMARY_BRIDGE_PORT;
|
2019-06-27 18:01:24 +03:00
|
|
|
cmdlength = SBP_DATA_SIZEOF(set_primary);
|
2014-01-14 18:54:11 +04:00
|
|
|
break;
|
|
|
|
case QETH_SBP_ROLE_SECONDARY:
|
|
|
|
setcmd = IPA_SBP_SET_SECONDARY_BRIDGE_PORT;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
if (!(card->options.sbp.supported_funcs & setcmd))
|
|
|
|
return -EOPNOTSUPP;
|
2017-08-15 18:02:47 +03:00
|
|
|
iob = qeth_sbp_build_cmd(card, setcmd, cmdlength);
|
2015-01-21 15:39:10 +03:00
|
|
|
if (!iob)
|
|
|
|
return -ENOMEM;
|
2019-02-12 20:33:24 +03:00
|
|
|
|
|
|
|
return qeth_send_ipa_cmd(card, iob, qeth_bridgeport_set_cb, NULL);
|
2014-01-14 18:54:11 +04:00
|
|
|
}
|
|
|
|
|
2014-01-14 18:54:13 +04:00
|
|
|
/**
|
|
|
|
* qeth_anset_makerc() - derive "traditional" error from hardware codes.
|
|
|
|
* @card: qeth_card structure pointer, for debug messages.
|
|
|
|
*
|
|
|
|
* Returns negative errno-compatible error indication or 0 on success.
|
|
|
|
*/
|
|
|
|
static int qeth_anset_makerc(struct qeth_card *card, int pnso_rc, u16 response)
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
if (pnso_rc == 0)
|
|
|
|
switch (response) {
|
|
|
|
case 0x0001:
|
|
|
|
rc = 0;
|
|
|
|
break;
|
|
|
|
case 0x0004:
|
|
|
|
case 0x0100:
|
|
|
|
case 0x0106:
|
2015-05-18 15:27:58 +03:00
|
|
|
rc = -EOPNOTSUPP;
|
2014-01-14 18:54:13 +04:00
|
|
|
dev_err(&card->gdev->dev,
|
|
|
|
"Setting address notification failed\n");
|
|
|
|
break;
|
|
|
|
case 0x0107:
|
|
|
|
rc = -EAGAIN;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
rc = -EIO;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
rc = -EIO;
|
|
|
|
|
|
|
|
if (rc) {
|
|
|
|
QETH_CARD_TEXT_(card, 2, "SBPp%04x", pnso_rc);
|
|
|
|
QETH_CARD_TEXT_(card, 2, "SBPr%04x", response);
|
|
|
|
}
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void qeth_bridgeport_an_set_cb(void *priv,
|
|
|
|
enum qdio_brinfo_entry_type type, void *entry)
|
|
|
|
{
|
|
|
|
struct qeth_card *card = (struct qeth_card *)priv;
|
|
|
|
struct qdio_brinfo_entry_l2 *l2entry;
|
|
|
|
u8 code;
|
|
|
|
|
|
|
|
if (type != l2_addr_lnid) {
|
|
|
|
WARN_ON_ONCE(1);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
l2entry = (struct qdio_brinfo_entry_l2 *)entry;
|
|
|
|
code = IPA_ADDR_CHANGE_CODE_MACADDR;
|
2019-06-05 14:48:50 +03:00
|
|
|
if (l2entry->addr_lnid.lnid < VLAN_N_VID)
|
2014-01-14 18:54:13 +04:00
|
|
|
code |= IPA_ADDR_CHANGE_CODE_VLANID;
|
|
|
|
qeth_bridge_emit_host_event(card, anev_reg_unreg, code,
|
|
|
|
(struct net_if_token *)&l2entry->nit,
|
|
|
|
(struct mac_addr_lnid *)&l2entry->addr_lnid);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* qeth_bridgeport_an_set() - Enable or disable bridgeport address notification
|
|
|
|
* @card: qeth_card structure pointer.
|
|
|
|
* @enable: 0 - disable, non-zero - enable notifications
|
|
|
|
*
|
|
|
|
* Returns negative errno-compatible error indication or 0 on success.
|
|
|
|
*
|
|
|
|
* On enable, emits a series of address notifications udev events for all
|
|
|
|
* currently registered hosts.
|
|
|
|
*/
|
|
|
|
int qeth_bridgeport_an_set(struct qeth_card *card, int enable)
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
u16 response;
|
|
|
|
struct ccw_device *ddev;
|
|
|
|
struct subchannel_id schid;
|
|
|
|
|
|
|
|
if (!card->options.sbp.supported_funcs)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
ddev = CARD_DDEV(card);
|
|
|
|
ccw_device_get_schid(ddev, &schid);
|
|
|
|
|
|
|
|
if (enable) {
|
|
|
|
qeth_bridge_emit_host_event(card, anev_reset, 0, NULL, NULL);
|
|
|
|
rc = qdio_pnso_brinfo(schid, 1, &response,
|
|
|
|
qeth_bridgeport_an_set_cb, card);
|
|
|
|
} else
|
|
|
|
rc = qdio_pnso_brinfo(schid, 0, &response, NULL, NULL);
|
|
|
|
return qeth_anset_makerc(card, rc, response);
|
|
|
|
}
|
|
|
|
|
2017-09-18 22:18:15 +03:00
|
|
|
static bool qeth_bridgeport_is_in_use(struct qeth_card *card)
|
|
|
|
{
|
|
|
|
return (card->options.sbp.role || card->options.sbp.reflect_promisc ||
|
|
|
|
card->options.sbp.hostnotification);
|
|
|
|
}
|
|
|
|
|
s390/qeth: add basic VNICC support
VNIC Characteristics (VNICC) are features of HiperSockets that define
how packets are handled by the underlying network hardware. For example,
if the VNICC flooding is configured on a qeth device, ethernet frames to
unknown destination MAC addresses are received.
Currently, there is support for seven VNICCs: flooding, multicast
flooding, receive broadcast, learning, takeover learning, takeover
setvmac, bridge invisible. Also, six IPA commands exist for configuring
VNICCs on a qeth device: query characteristics, query commands, enable
characteristic, disable characteristic, set timeout, get timeout.
This patch adds the basic code infrastructure for VNICC support to qeth.
It allows querying VNICC support from the underlying hardware. To this
end, it adds:
* basic message formats for IPA commands
* basic data structures
* basic error handling
* query characteristics IPA command support
The query characteristics IPA command allows requesting the currently
supported and currently enabled VNIC characteristics from the underlying
hardware.
Support for the other IPA commands and for the configuration of VNICCs
is added in follow-up patches together with the respective user
interface functions.
Signed-off-by: Hans Wippel <hwippel@linux.vnet.ibm.com>
Reviewed-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-09-18 22:18:14 +03:00
|
|
|
/* VNIC Characteristics support */
|
|
|
|
|
|
|
|
/* handle VNICC IPA command return codes; convert to error codes */
|
2019-02-12 20:33:25 +03:00
|
|
|
static int qeth_l2_vnicc_makerc(struct qeth_card *card, u16 ipa_rc)
|
s390/qeth: add basic VNICC support
VNIC Characteristics (VNICC) are features of HiperSockets that define
how packets are handled by the underlying network hardware. For example,
if the VNICC flooding is configured on a qeth device, ethernet frames to
unknown destination MAC addresses are received.
Currently, there is support for seven VNICCs: flooding, multicast
flooding, receive broadcast, learning, takeover learning, takeover
setvmac, bridge invisible. Also, six IPA commands exist for configuring
VNICCs on a qeth device: query characteristics, query commands, enable
characteristic, disable characteristic, set timeout, get timeout.
This patch adds the basic code infrastructure for VNICC support to qeth.
It allows querying VNICC support from the underlying hardware. To this
end, it adds:
* basic message formats for IPA commands
* basic data structures
* basic error handling
* query characteristics IPA command support
The query characteristics IPA command allows requesting the currently
supported and currently enabled VNIC characteristics from the underlying
hardware.
Support for the other IPA commands and for the configuration of VNICCs
is added in follow-up patches together with the respective user
interface functions.
Signed-off-by: Hans Wippel <hwippel@linux.vnet.ibm.com>
Reviewed-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-09-18 22:18:14 +03:00
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
switch (ipa_rc) {
|
|
|
|
case IPA_RC_SUCCESS:
|
|
|
|
return ipa_rc;
|
|
|
|
case IPA_RC_L2_UNSUPPORTED_CMD:
|
|
|
|
case IPA_RC_NOTSUPP:
|
|
|
|
rc = -EOPNOTSUPP;
|
|
|
|
break;
|
|
|
|
case IPA_RC_VNICC_OOSEQ:
|
|
|
|
rc = -EALREADY;
|
|
|
|
break;
|
|
|
|
case IPA_RC_VNICC_VNICBP:
|
|
|
|
rc = -EBUSY;
|
|
|
|
break;
|
|
|
|
case IPA_RC_L2_ADDR_TABLE_FULL:
|
|
|
|
rc = -ENOSPC;
|
|
|
|
break;
|
|
|
|
case IPA_RC_L2_MAC_NOT_AUTH_BY_ADP:
|
|
|
|
rc = -EACCES;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
rc = -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
QETH_CARD_TEXT_(card, 2, "err%04x", ipa_rc);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* generic VNICC request call back */
|
|
|
|
static int qeth_l2_vnicc_request_cb(struct qeth_card *card,
|
|
|
|
struct qeth_reply *reply,
|
|
|
|
unsigned long data)
|
|
|
|
{
|
|
|
|
struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
|
|
|
|
struct qeth_ipacmd_vnicc *rep = &cmd->data.vnicc;
|
2019-08-20 17:46:40 +03:00
|
|
|
u32 sub_cmd = cmd->data.vnicc.hdr.sub_command;
|
s390/qeth: add basic VNICC support
VNIC Characteristics (VNICC) are features of HiperSockets that define
how packets are handled by the underlying network hardware. For example,
if the VNICC flooding is configured on a qeth device, ethernet frames to
unknown destination MAC addresses are received.
Currently, there is support for seven VNICCs: flooding, multicast
flooding, receive broadcast, learning, takeover learning, takeover
setvmac, bridge invisible. Also, six IPA commands exist for configuring
VNICCs on a qeth device: query characteristics, query commands, enable
characteristic, disable characteristic, set timeout, get timeout.
This patch adds the basic code infrastructure for VNICC support to qeth.
It allows querying VNICC support from the underlying hardware. To this
end, it adds:
* basic message formats for IPA commands
* basic data structures
* basic error handling
* query characteristics IPA command support
The query characteristics IPA command allows requesting the currently
supported and currently enabled VNIC characteristics from the underlying
hardware.
Support for the other IPA commands and for the configuration of VNICCs
is added in follow-up patches together with the respective user
interface functions.
Signed-off-by: Hans Wippel <hwippel@linux.vnet.ibm.com>
Reviewed-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-09-18 22:18:14 +03:00
|
|
|
|
|
|
|
QETH_CARD_TEXT(card, 2, "vniccrcb");
|
|
|
|
if (cmd->hdr.return_code)
|
2019-02-12 20:33:25 +03:00
|
|
|
return qeth_l2_vnicc_makerc(card, cmd->hdr.return_code);
|
s390/qeth: add basic VNICC support
VNIC Characteristics (VNICC) are features of HiperSockets that define
how packets are handled by the underlying network hardware. For example,
if the VNICC flooding is configured on a qeth device, ethernet frames to
unknown destination MAC addresses are received.
Currently, there is support for seven VNICCs: flooding, multicast
flooding, receive broadcast, learning, takeover learning, takeover
setvmac, bridge invisible. Also, six IPA commands exist for configuring
VNICCs on a qeth device: query characteristics, query commands, enable
characteristic, disable characteristic, set timeout, get timeout.
This patch adds the basic code infrastructure for VNICC support to qeth.
It allows querying VNICC support from the underlying hardware. To this
end, it adds:
* basic message formats for IPA commands
* basic data structures
* basic error handling
* query characteristics IPA command support
The query characteristics IPA command allows requesting the currently
supported and currently enabled VNIC characteristics from the underlying
hardware.
Support for the other IPA commands and for the configuration of VNICCs
is added in follow-up patches together with the respective user
interface functions.
Signed-off-by: Hans Wippel <hwippel@linux.vnet.ibm.com>
Reviewed-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-09-18 22:18:14 +03:00
|
|
|
/* return results to caller */
|
2019-06-27 18:01:26 +03:00
|
|
|
card->options.vnicc.sup_chars = rep->vnicc_cmds.supported;
|
|
|
|
card->options.vnicc.cur_chars = rep->vnicc_cmds.enabled;
|
s390/qeth: add basic VNICC support
VNIC Characteristics (VNICC) are features of HiperSockets that define
how packets are handled by the underlying network hardware. For example,
if the VNICC flooding is configured on a qeth device, ethernet frames to
unknown destination MAC addresses are received.
Currently, there is support for seven VNICCs: flooding, multicast
flooding, receive broadcast, learning, takeover learning, takeover
setvmac, bridge invisible. Also, six IPA commands exist for configuring
VNICCs on a qeth device: query characteristics, query commands, enable
characteristic, disable characteristic, set timeout, get timeout.
This patch adds the basic code infrastructure for VNICC support to qeth.
It allows querying VNICC support from the underlying hardware. To this
end, it adds:
* basic message formats for IPA commands
* basic data structures
* basic error handling
* query characteristics IPA command support
The query characteristics IPA command allows requesting the currently
supported and currently enabled VNIC characteristics from the underlying
hardware.
Support for the other IPA commands and for the configuration of VNICCs
is added in follow-up patches together with the respective user
interface functions.
Signed-off-by: Hans Wippel <hwippel@linux.vnet.ibm.com>
Reviewed-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-09-18 22:18:14 +03:00
|
|
|
|
2019-08-20 17:46:40 +03:00
|
|
|
if (sub_cmd == IPA_VNICC_QUERY_CMDS)
|
2020-03-06 11:13:11 +03:00
|
|
|
*(u32 *)reply->param = rep->data.query_cmds.sup_cmds;
|
2019-08-20 17:46:40 +03:00
|
|
|
else if (sub_cmd == IPA_VNICC_GET_TIMEOUT)
|
2020-03-06 11:13:11 +03:00
|
|
|
*(u32 *)reply->param = rep->data.getset_timeout.timeout;
|
2017-09-18 22:18:16 +03:00
|
|
|
|
s390/qeth: add basic VNICC support
VNIC Characteristics (VNICC) are features of HiperSockets that define
how packets are handled by the underlying network hardware. For example,
if the VNICC flooding is configured on a qeth device, ethernet frames to
unknown destination MAC addresses are received.
Currently, there is support for seven VNICCs: flooding, multicast
flooding, receive broadcast, learning, takeover learning, takeover
setvmac, bridge invisible. Also, six IPA commands exist for configuring
VNICCs on a qeth device: query characteristics, query commands, enable
characteristic, disable characteristic, set timeout, get timeout.
This patch adds the basic code infrastructure for VNICC support to qeth.
It allows querying VNICC support from the underlying hardware. To this
end, it adds:
* basic message formats for IPA commands
* basic data structures
* basic error handling
* query characteristics IPA command support
The query characteristics IPA command allows requesting the currently
supported and currently enabled VNIC characteristics from the underlying
hardware.
Support for the other IPA commands and for the configuration of VNICCs
is added in follow-up patches together with the respective user
interface functions.
Signed-off-by: Hans Wippel <hwippel@linux.vnet.ibm.com>
Reviewed-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-09-18 22:18:14 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-06-27 18:01:26 +03:00
|
|
|
static struct qeth_cmd_buffer *qeth_l2_vnicc_build_cmd(struct qeth_card *card,
|
|
|
|
u32 vnicc_cmd,
|
|
|
|
unsigned int data_length)
|
s390/qeth: add basic VNICC support
VNIC Characteristics (VNICC) are features of HiperSockets that define
how packets are handled by the underlying network hardware. For example,
if the VNICC flooding is configured on a qeth device, ethernet frames to
unknown destination MAC addresses are received.
Currently, there is support for seven VNICCs: flooding, multicast
flooding, receive broadcast, learning, takeover learning, takeover
setvmac, bridge invisible. Also, six IPA commands exist for configuring
VNICCs on a qeth device: query characteristics, query commands, enable
characteristic, disable characteristic, set timeout, get timeout.
This patch adds the basic code infrastructure for VNICC support to qeth.
It allows querying VNICC support from the underlying hardware. To this
end, it adds:
* basic message formats for IPA commands
* basic data structures
* basic error handling
* query characteristics IPA command support
The query characteristics IPA command allows requesting the currently
supported and currently enabled VNIC characteristics from the underlying
hardware.
Support for the other IPA commands and for the configuration of VNICCs
is added in follow-up patches together with the respective user
interface functions.
Signed-off-by: Hans Wippel <hwippel@linux.vnet.ibm.com>
Reviewed-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-09-18 22:18:14 +03:00
|
|
|
{
|
2019-06-27 18:01:26 +03:00
|
|
|
struct qeth_ipacmd_vnicc_hdr *hdr;
|
s390/qeth: add basic VNICC support
VNIC Characteristics (VNICC) are features of HiperSockets that define
how packets are handled by the underlying network hardware. For example,
if the VNICC flooding is configured on a qeth device, ethernet frames to
unknown destination MAC addresses are received.
Currently, there is support for seven VNICCs: flooding, multicast
flooding, receive broadcast, learning, takeover learning, takeover
setvmac, bridge invisible. Also, six IPA commands exist for configuring
VNICCs on a qeth device: query characteristics, query commands, enable
characteristic, disable characteristic, set timeout, get timeout.
This patch adds the basic code infrastructure for VNICC support to qeth.
It allows querying VNICC support from the underlying hardware. To this
end, it adds:
* basic message formats for IPA commands
* basic data structures
* basic error handling
* query characteristics IPA command support
The query characteristics IPA command allows requesting the currently
supported and currently enabled VNIC characteristics from the underlying
hardware.
Support for the other IPA commands and for the configuration of VNICCs
is added in follow-up patches together with the respective user
interface functions.
Signed-off-by: Hans Wippel <hwippel@linux.vnet.ibm.com>
Reviewed-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-09-18 22:18:14 +03:00
|
|
|
struct qeth_cmd_buffer *iob;
|
|
|
|
|
2019-06-27 18:01:26 +03:00
|
|
|
iob = qeth_ipa_alloc_cmd(card, IPA_CMD_VNICC, QETH_PROT_NONE,
|
|
|
|
data_length +
|
|
|
|
offsetof(struct qeth_ipacmd_vnicc, data));
|
s390/qeth: add basic VNICC support
VNIC Characteristics (VNICC) are features of HiperSockets that define
how packets are handled by the underlying network hardware. For example,
if the VNICC flooding is configured on a qeth device, ethernet frames to
unknown destination MAC addresses are received.
Currently, there is support for seven VNICCs: flooding, multicast
flooding, receive broadcast, learning, takeover learning, takeover
setvmac, bridge invisible. Also, six IPA commands exist for configuring
VNICCs on a qeth device: query characteristics, query commands, enable
characteristic, disable characteristic, set timeout, get timeout.
This patch adds the basic code infrastructure for VNICC support to qeth.
It allows querying VNICC support from the underlying hardware. To this
end, it adds:
* basic message formats for IPA commands
* basic data structures
* basic error handling
* query characteristics IPA command support
The query characteristics IPA command allows requesting the currently
supported and currently enabled VNIC characteristics from the underlying
hardware.
Support for the other IPA commands and for the configuration of VNICCs
is added in follow-up patches together with the respective user
interface functions.
Signed-off-by: Hans Wippel <hwippel@linux.vnet.ibm.com>
Reviewed-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-09-18 22:18:14 +03:00
|
|
|
if (!iob)
|
2019-06-27 18:01:26 +03:00
|
|
|
return NULL;
|
s390/qeth: add basic VNICC support
VNIC Characteristics (VNICC) are features of HiperSockets that define
how packets are handled by the underlying network hardware. For example,
if the VNICC flooding is configured on a qeth device, ethernet frames to
unknown destination MAC addresses are received.
Currently, there is support for seven VNICCs: flooding, multicast
flooding, receive broadcast, learning, takeover learning, takeover
setvmac, bridge invisible. Also, six IPA commands exist for configuring
VNICCs on a qeth device: query characteristics, query commands, enable
characteristic, disable characteristic, set timeout, get timeout.
This patch adds the basic code infrastructure for VNICC support to qeth.
It allows querying VNICC support from the underlying hardware. To this
end, it adds:
* basic message formats for IPA commands
* basic data structures
* basic error handling
* query characteristics IPA command support
The query characteristics IPA command allows requesting the currently
supported and currently enabled VNIC characteristics from the underlying
hardware.
Support for the other IPA commands and for the configuration of VNICCs
is added in follow-up patches together with the respective user
interface functions.
Signed-off-by: Hans Wippel <hwippel@linux.vnet.ibm.com>
Reviewed-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-09-18 22:18:14 +03:00
|
|
|
|
2019-06-27 18:01:26 +03:00
|
|
|
hdr = &__ipa_cmd(iob)->data.vnicc.hdr;
|
|
|
|
hdr->data_length = sizeof(*hdr) + data_length;
|
|
|
|
hdr->sub_command = vnicc_cmd;
|
|
|
|
return iob;
|
s390/qeth: add basic VNICC support
VNIC Characteristics (VNICC) are features of HiperSockets that define
how packets are handled by the underlying network hardware. For example,
if the VNICC flooding is configured on a qeth device, ethernet frames to
unknown destination MAC addresses are received.
Currently, there is support for seven VNICCs: flooding, multicast
flooding, receive broadcast, learning, takeover learning, takeover
setvmac, bridge invisible. Also, six IPA commands exist for configuring
VNICCs on a qeth device: query characteristics, query commands, enable
characteristic, disable characteristic, set timeout, get timeout.
This patch adds the basic code infrastructure for VNICC support to qeth.
It allows querying VNICC support from the underlying hardware. To this
end, it adds:
* basic message formats for IPA commands
* basic data structures
* basic error handling
* query characteristics IPA command support
The query characteristics IPA command allows requesting the currently
supported and currently enabled VNIC characteristics from the underlying
hardware.
Support for the other IPA commands and for the configuration of VNICCs
is added in follow-up patches together with the respective user
interface functions.
Signed-off-by: Hans Wippel <hwippel@linux.vnet.ibm.com>
Reviewed-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-09-18 22:18:14 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* VNICC query VNIC characteristics request */
|
|
|
|
static int qeth_l2_vnicc_query_chars(struct qeth_card *card)
|
|
|
|
{
|
2019-06-27 18:01:26 +03:00
|
|
|
struct qeth_cmd_buffer *iob;
|
|
|
|
|
|
|
|
QETH_CARD_TEXT(card, 2, "vniccqch");
|
|
|
|
iob = qeth_l2_vnicc_build_cmd(card, IPA_VNICC_QUERY_CHARS, 0);
|
|
|
|
if (!iob)
|
|
|
|
return -ENOMEM;
|
s390/qeth: add basic VNICC support
VNIC Characteristics (VNICC) are features of HiperSockets that define
how packets are handled by the underlying network hardware. For example,
if the VNICC flooding is configured on a qeth device, ethernet frames to
unknown destination MAC addresses are received.
Currently, there is support for seven VNICCs: flooding, multicast
flooding, receive broadcast, learning, takeover learning, takeover
setvmac, bridge invisible. Also, six IPA commands exist for configuring
VNICCs on a qeth device: query characteristics, query commands, enable
characteristic, disable characteristic, set timeout, get timeout.
This patch adds the basic code infrastructure for VNICC support to qeth.
It allows querying VNICC support from the underlying hardware. To this
end, it adds:
* basic message formats for IPA commands
* basic data structures
* basic error handling
* query characteristics IPA command support
The query characteristics IPA command allows requesting the currently
supported and currently enabled VNIC characteristics from the underlying
hardware.
Support for the other IPA commands and for the configuration of VNICCs
is added in follow-up patches together with the respective user
interface functions.
Signed-off-by: Hans Wippel <hwippel@linux.vnet.ibm.com>
Reviewed-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-09-18 22:18:14 +03:00
|
|
|
|
2019-08-20 17:46:40 +03:00
|
|
|
return qeth_send_ipa_cmd(card, iob, qeth_l2_vnicc_request_cb, NULL);
|
s390/qeth: add basic VNICC support
VNIC Characteristics (VNICC) are features of HiperSockets that define
how packets are handled by the underlying network hardware. For example,
if the VNICC flooding is configured on a qeth device, ethernet frames to
unknown destination MAC addresses are received.
Currently, there is support for seven VNICCs: flooding, multicast
flooding, receive broadcast, learning, takeover learning, takeover
setvmac, bridge invisible. Also, six IPA commands exist for configuring
VNICCs on a qeth device: query characteristics, query commands, enable
characteristic, disable characteristic, set timeout, get timeout.
This patch adds the basic code infrastructure for VNICC support to qeth.
It allows querying VNICC support from the underlying hardware. To this
end, it adds:
* basic message formats for IPA commands
* basic data structures
* basic error handling
* query characteristics IPA command support
The query characteristics IPA command allows requesting the currently
supported and currently enabled VNIC characteristics from the underlying
hardware.
Support for the other IPA commands and for the configuration of VNICCs
is added in follow-up patches together with the respective user
interface functions.
Signed-off-by: Hans Wippel <hwippel@linux.vnet.ibm.com>
Reviewed-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-09-18 22:18:14 +03:00
|
|
|
}
|
|
|
|
|
2017-09-18 22:18:15 +03:00
|
|
|
/* VNICC query sub commands request */
|
|
|
|
static int qeth_l2_vnicc_query_cmds(struct qeth_card *card, u32 vnic_char,
|
|
|
|
u32 *sup_cmds)
|
|
|
|
{
|
2019-06-27 18:01:26 +03:00
|
|
|
struct qeth_cmd_buffer *iob;
|
|
|
|
|
|
|
|
QETH_CARD_TEXT(card, 2, "vniccqcm");
|
|
|
|
iob = qeth_l2_vnicc_build_cmd(card, IPA_VNICC_QUERY_CMDS,
|
|
|
|
VNICC_DATA_SIZEOF(query_cmds));
|
|
|
|
if (!iob)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
__ipa_cmd(iob)->data.vnicc.data.query_cmds.vnic_char = vnic_char;
|
2017-09-18 22:18:15 +03:00
|
|
|
|
2020-03-06 11:13:11 +03:00
|
|
|
return qeth_send_ipa_cmd(card, iob, qeth_l2_vnicc_request_cb, sup_cmds);
|
2017-09-18 22:18:15 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* VNICC enable/disable characteristic request */
|
|
|
|
static int qeth_l2_vnicc_set_char(struct qeth_card *card, u32 vnic_char,
|
|
|
|
u32 cmd)
|
|
|
|
{
|
2019-06-27 18:01:26 +03:00
|
|
|
struct qeth_cmd_buffer *iob;
|
|
|
|
|
|
|
|
QETH_CARD_TEXT(card, 2, "vniccedc");
|
|
|
|
iob = qeth_l2_vnicc_build_cmd(card, cmd, VNICC_DATA_SIZEOF(set_char));
|
|
|
|
if (!iob)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
__ipa_cmd(iob)->data.vnicc.data.set_char.vnic_char = vnic_char;
|
2017-09-18 22:18:15 +03:00
|
|
|
|
2019-08-20 17:46:40 +03:00
|
|
|
return qeth_send_ipa_cmd(card, iob, qeth_l2_vnicc_request_cb, NULL);
|
2017-09-18 22:18:15 +03:00
|
|
|
}
|
|
|
|
|
2017-09-18 22:18:16 +03:00
|
|
|
/* VNICC get/set timeout for characteristic request */
|
|
|
|
static int qeth_l2_vnicc_getset_timeout(struct qeth_card *card, u32 vnicc,
|
|
|
|
u32 cmd, u32 *timeout)
|
|
|
|
{
|
2019-06-27 18:01:26 +03:00
|
|
|
struct qeth_vnicc_getset_timeout *getset_timeout;
|
|
|
|
struct qeth_cmd_buffer *iob;
|
|
|
|
|
|
|
|
QETH_CARD_TEXT(card, 2, "vniccgst");
|
|
|
|
iob = qeth_l2_vnicc_build_cmd(card, cmd,
|
|
|
|
VNICC_DATA_SIZEOF(getset_timeout));
|
|
|
|
if (!iob)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
getset_timeout = &__ipa_cmd(iob)->data.vnicc.data.getset_timeout;
|
|
|
|
getset_timeout->vnic_char = vnicc;
|
|
|
|
|
|
|
|
if (cmd == IPA_VNICC_SET_TIMEOUT)
|
|
|
|
getset_timeout->timeout = *timeout;
|
2017-09-18 22:18:16 +03:00
|
|
|
|
2020-03-06 11:13:11 +03:00
|
|
|
return qeth_send_ipa_cmd(card, iob, qeth_l2_vnicc_request_cb, timeout);
|
2017-09-18 22:18:16 +03:00
|
|
|
}
|
|
|
|
|
2017-09-18 22:18:15 +03:00
|
|
|
/* set current VNICC flag state; called from sysfs store function */
|
|
|
|
int qeth_l2_vnicc_set_state(struct qeth_card *card, u32 vnicc, bool state)
|
|
|
|
{
|
|
|
|
int rc = 0;
|
|
|
|
u32 cmd;
|
|
|
|
|
|
|
|
QETH_CARD_TEXT(card, 2, "vniccsch");
|
|
|
|
|
|
|
|
/* check if characteristic and enable/disable are supported */
|
|
|
|
if (!(card->options.vnicc.sup_chars & vnicc) ||
|
|
|
|
!(card->options.vnicc.set_char_sup & vnicc))
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2020-02-20 17:54:54 +03:00
|
|
|
if (qeth_bridgeport_is_in_use(card))
|
|
|
|
return -EBUSY;
|
|
|
|
|
2017-09-18 22:18:15 +03:00
|
|
|
/* set enable/disable command and store wanted characteristic */
|
|
|
|
if (state) {
|
|
|
|
cmd = IPA_VNICC_ENABLE;
|
|
|
|
card->options.vnicc.wanted_chars |= vnicc;
|
|
|
|
} else {
|
|
|
|
cmd = IPA_VNICC_DISABLE;
|
|
|
|
card->options.vnicc.wanted_chars &= ~vnicc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* do we need to do anything? */
|
|
|
|
if (card->options.vnicc.cur_chars == card->options.vnicc.wanted_chars)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
/* if card is not ready, simply stop here */
|
|
|
|
if (!qeth_card_hw_is_reachable(card)) {
|
|
|
|
if (state)
|
|
|
|
card->options.vnicc.cur_chars |= vnicc;
|
|
|
|
else
|
|
|
|
card->options.vnicc.cur_chars &= ~vnicc;
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
rc = qeth_l2_vnicc_set_char(card, vnicc, cmd);
|
|
|
|
if (rc)
|
|
|
|
card->options.vnicc.wanted_chars =
|
|
|
|
card->options.vnicc.cur_chars;
|
2017-09-18 22:18:16 +03:00
|
|
|
else {
|
|
|
|
/* successful online VNICC change; handle special cases */
|
|
|
|
if (state && vnicc == QETH_VNICC_RX_BCAST)
|
|
|
|
card->options.vnicc.rx_bcast_enabled = true;
|
|
|
|
if (!state && vnicc == QETH_VNICC_LEARNING)
|
|
|
|
qeth_l2_vnicc_recover_timeout(card, vnicc,
|
|
|
|
&card->options.vnicc.learning_timeout);
|
|
|
|
}
|
2017-09-18 22:18:15 +03:00
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* get current VNICC flag state; called from sysfs show function */
|
|
|
|
int qeth_l2_vnicc_get_state(struct qeth_card *card, u32 vnicc, bool *state)
|
|
|
|
{
|
|
|
|
int rc = 0;
|
|
|
|
|
|
|
|
QETH_CARD_TEXT(card, 2, "vniccgch");
|
|
|
|
|
|
|
|
/* check if characteristic is supported */
|
|
|
|
if (!(card->options.vnicc.sup_chars & vnicc))
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2020-02-20 17:54:54 +03:00
|
|
|
if (qeth_bridgeport_is_in_use(card))
|
|
|
|
return -EBUSY;
|
|
|
|
|
2017-09-18 22:18:15 +03:00
|
|
|
/* if card is ready, query current VNICC state */
|
|
|
|
if (qeth_card_hw_is_reachable(card))
|
|
|
|
rc = qeth_l2_vnicc_query_chars(card);
|
|
|
|
|
|
|
|
*state = (card->options.vnicc.cur_chars & vnicc) ? true : false;
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2017-09-18 22:18:16 +03:00
|
|
|
/* set VNICC timeout; called from sysfs store function. Currently, only learning
|
|
|
|
* supports timeout
|
|
|
|
*/
|
|
|
|
int qeth_l2_vnicc_set_timeout(struct qeth_card *card, u32 timeout)
|
|
|
|
{
|
|
|
|
int rc = 0;
|
|
|
|
|
|
|
|
QETH_CARD_TEXT(card, 2, "vniccsto");
|
|
|
|
|
|
|
|
/* check if characteristic and set_timeout are supported */
|
|
|
|
if (!(card->options.vnicc.sup_chars & QETH_VNICC_LEARNING) ||
|
|
|
|
!(card->options.vnicc.getset_timeout_sup & QETH_VNICC_LEARNING))
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2020-02-20 17:54:54 +03:00
|
|
|
if (qeth_bridgeport_is_in_use(card))
|
|
|
|
return -EBUSY;
|
|
|
|
|
2017-09-18 22:18:16 +03:00
|
|
|
/* do we need to do anything? */
|
|
|
|
if (card->options.vnicc.learning_timeout == timeout)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
/* if card is not ready, simply store the value internally and return */
|
|
|
|
if (!qeth_card_hw_is_reachable(card)) {
|
|
|
|
card->options.vnicc.learning_timeout = timeout;
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* send timeout value to card; if successful, store value internally */
|
|
|
|
rc = qeth_l2_vnicc_getset_timeout(card, QETH_VNICC_LEARNING,
|
|
|
|
IPA_VNICC_SET_TIMEOUT, &timeout);
|
|
|
|
if (!rc)
|
|
|
|
card->options.vnicc.learning_timeout = timeout;
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* get current VNICC timeout; called from sysfs show function. Currently, only
|
|
|
|
* learning supports timeout
|
|
|
|
*/
|
|
|
|
int qeth_l2_vnicc_get_timeout(struct qeth_card *card, u32 *timeout)
|
|
|
|
{
|
|
|
|
int rc = 0;
|
|
|
|
|
|
|
|
QETH_CARD_TEXT(card, 2, "vniccgto");
|
|
|
|
|
|
|
|
/* check if characteristic and get_timeout are supported */
|
|
|
|
if (!(card->options.vnicc.sup_chars & QETH_VNICC_LEARNING) ||
|
|
|
|
!(card->options.vnicc.getset_timeout_sup & QETH_VNICC_LEARNING))
|
|
|
|
return -EOPNOTSUPP;
|
2020-02-20 17:54:54 +03:00
|
|
|
|
|
|
|
if (qeth_bridgeport_is_in_use(card))
|
|
|
|
return -EBUSY;
|
|
|
|
|
2017-09-18 22:18:16 +03:00
|
|
|
/* if card is ready, get timeout. Otherwise, just return stored value */
|
|
|
|
*timeout = card->options.vnicc.learning_timeout;
|
|
|
|
if (qeth_card_hw_is_reachable(card))
|
|
|
|
rc = qeth_l2_vnicc_getset_timeout(card, QETH_VNICC_LEARNING,
|
|
|
|
IPA_VNICC_GET_TIMEOUT,
|
|
|
|
timeout);
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2017-09-18 22:18:15 +03:00
|
|
|
/* check if VNICC is currently enabled */
|
|
|
|
bool qeth_l2_vnicc_is_in_use(struct qeth_card *card)
|
|
|
|
{
|
2019-12-23 17:03:24 +03:00
|
|
|
if (!card->options.vnicc.sup_chars)
|
2017-09-18 22:18:15 +03:00
|
|
|
return false;
|
|
|
|
/* default values are only OK if rx_bcast was not enabled by user
|
|
|
|
* or the card is offline.
|
|
|
|
*/
|
|
|
|
if (card->options.vnicc.cur_chars == QETH_VNICC_DEFAULT) {
|
|
|
|
if (!card->options.vnicc.rx_bcast_enabled ||
|
|
|
|
!qeth_card_hw_is_reachable(card))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2017-09-18 22:18:16 +03:00
|
|
|
/* recover user timeout setting */
|
|
|
|
static bool qeth_l2_vnicc_recover_timeout(struct qeth_card *card, u32 vnicc,
|
|
|
|
u32 *timeout)
|
|
|
|
{
|
|
|
|
if (card->options.vnicc.sup_chars & vnicc &&
|
|
|
|
card->options.vnicc.getset_timeout_sup & vnicc &&
|
|
|
|
!qeth_l2_vnicc_getset_timeout(card, vnicc, IPA_VNICC_SET_TIMEOUT,
|
|
|
|
timeout))
|
|
|
|
return false;
|
|
|
|
*timeout = QETH_VNICC_DEFAULT_TIMEOUT;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2017-09-18 22:18:15 +03:00
|
|
|
/* recover user characteristic setting */
|
|
|
|
static bool qeth_l2_vnicc_recover_char(struct qeth_card *card, u32 vnicc,
|
|
|
|
bool enable)
|
|
|
|
{
|
|
|
|
u32 cmd = enable ? IPA_VNICC_ENABLE : IPA_VNICC_DISABLE;
|
|
|
|
|
|
|
|
if (card->options.vnicc.sup_chars & vnicc &&
|
|
|
|
card->options.vnicc.set_char_sup & vnicc &&
|
|
|
|
!qeth_l2_vnicc_set_char(card, vnicc, cmd))
|
|
|
|
return false;
|
|
|
|
card->options.vnicc.wanted_chars &= ~vnicc;
|
|
|
|
card->options.vnicc.wanted_chars |= QETH_VNICC_DEFAULT & vnicc;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
s390/qeth: add basic VNICC support
VNIC Characteristics (VNICC) are features of HiperSockets that define
how packets are handled by the underlying network hardware. For example,
if the VNICC flooding is configured on a qeth device, ethernet frames to
unknown destination MAC addresses are received.
Currently, there is support for seven VNICCs: flooding, multicast
flooding, receive broadcast, learning, takeover learning, takeover
setvmac, bridge invisible. Also, six IPA commands exist for configuring
VNICCs on a qeth device: query characteristics, query commands, enable
characteristic, disable characteristic, set timeout, get timeout.
This patch adds the basic code infrastructure for VNICC support to qeth.
It allows querying VNICC support from the underlying hardware. To this
end, it adds:
* basic message formats for IPA commands
* basic data structures
* basic error handling
* query characteristics IPA command support
The query characteristics IPA command allows requesting the currently
supported and currently enabled VNIC characteristics from the underlying
hardware.
Support for the other IPA commands and for the configuration of VNICCs
is added in follow-up patches together with the respective user
interface functions.
Signed-off-by: Hans Wippel <hwippel@linux.vnet.ibm.com>
Reviewed-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-09-18 22:18:14 +03:00
|
|
|
/* (re-)initialize VNICC */
|
|
|
|
static void qeth_l2_vnicc_init(struct qeth_card *card)
|
|
|
|
{
|
2017-09-18 22:18:16 +03:00
|
|
|
u32 *timeout = &card->options.vnicc.learning_timeout;
|
2019-10-08 19:21:06 +03:00
|
|
|
bool enable, error = false;
|
2017-09-18 22:18:15 +03:00
|
|
|
unsigned int chars_len, i;
|
|
|
|
unsigned long chars_tmp;
|
|
|
|
u32 sup_cmds, vnicc;
|
|
|
|
|
s390/qeth: add basic VNICC support
VNIC Characteristics (VNICC) are features of HiperSockets that define
how packets are handled by the underlying network hardware. For example,
if the VNICC flooding is configured on a qeth device, ethernet frames to
unknown destination MAC addresses are received.
Currently, there is support for seven VNICCs: flooding, multicast
flooding, receive broadcast, learning, takeover learning, takeover
setvmac, bridge invisible. Also, six IPA commands exist for configuring
VNICCs on a qeth device: query characteristics, query commands, enable
characteristic, disable characteristic, set timeout, get timeout.
This patch adds the basic code infrastructure for VNICC support to qeth.
It allows querying VNICC support from the underlying hardware. To this
end, it adds:
* basic message formats for IPA commands
* basic data structures
* basic error handling
* query characteristics IPA command support
The query characteristics IPA command allows requesting the currently
supported and currently enabled VNIC characteristics from the underlying
hardware.
Support for the other IPA commands and for the configuration of VNICCs
is added in follow-up patches together with the respective user
interface functions.
Signed-off-by: Hans Wippel <hwippel@linux.vnet.ibm.com>
Reviewed-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-09-18 22:18:14 +03:00
|
|
|
QETH_CARD_TEXT(card, 2, "vniccini");
|
2017-09-18 22:18:15 +03:00
|
|
|
/* reset rx_bcast */
|
|
|
|
card->options.vnicc.rx_bcast_enabled = 0;
|
s390/qeth: add basic VNICC support
VNIC Characteristics (VNICC) are features of HiperSockets that define
how packets are handled by the underlying network hardware. For example,
if the VNICC flooding is configured on a qeth device, ethernet frames to
unknown destination MAC addresses are received.
Currently, there is support for seven VNICCs: flooding, multicast
flooding, receive broadcast, learning, takeover learning, takeover
setvmac, bridge invisible. Also, six IPA commands exist for configuring
VNICCs on a qeth device: query characteristics, query commands, enable
characteristic, disable characteristic, set timeout, get timeout.
This patch adds the basic code infrastructure for VNICC support to qeth.
It allows querying VNICC support from the underlying hardware. To this
end, it adds:
* basic message formats for IPA commands
* basic data structures
* basic error handling
* query characteristics IPA command support
The query characteristics IPA command allows requesting the currently
supported and currently enabled VNIC characteristics from the underlying
hardware.
Support for the other IPA commands and for the configuration of VNICCs
is added in follow-up patches together with the respective user
interface functions.
Signed-off-by: Hans Wippel <hwippel@linux.vnet.ibm.com>
Reviewed-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-09-18 22:18:14 +03:00
|
|
|
/* initial query and storage of VNIC characteristics */
|
|
|
|
if (qeth_l2_vnicc_query_chars(card)) {
|
2017-09-18 22:18:16 +03:00
|
|
|
if (card->options.vnicc.wanted_chars != QETH_VNICC_DEFAULT ||
|
|
|
|
*timeout != QETH_VNICC_DEFAULT_TIMEOUT)
|
2017-09-18 22:18:15 +03:00
|
|
|
dev_err(&card->gdev->dev, "Configuring the VNIC characteristics failed\n");
|
|
|
|
/* fail quietly if user didn't change the default config */
|
s390/qeth: add basic VNICC support
VNIC Characteristics (VNICC) are features of HiperSockets that define
how packets are handled by the underlying network hardware. For example,
if the VNICC flooding is configured on a qeth device, ethernet frames to
unknown destination MAC addresses are received.
Currently, there is support for seven VNICCs: flooding, multicast
flooding, receive broadcast, learning, takeover learning, takeover
setvmac, bridge invisible. Also, six IPA commands exist for configuring
VNICCs on a qeth device: query characteristics, query commands, enable
characteristic, disable characteristic, set timeout, get timeout.
This patch adds the basic code infrastructure for VNICC support to qeth.
It allows querying VNICC support from the underlying hardware. To this
end, it adds:
* basic message formats for IPA commands
* basic data structures
* basic error handling
* query characteristics IPA command support
The query characteristics IPA command allows requesting the currently
supported and currently enabled VNIC characteristics from the underlying
hardware.
Support for the other IPA commands and for the configuration of VNICCs
is added in follow-up patches together with the respective user
interface functions.
Signed-off-by: Hans Wippel <hwippel@linux.vnet.ibm.com>
Reviewed-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-09-18 22:18:14 +03:00
|
|
|
card->options.vnicc.sup_chars = 0;
|
|
|
|
card->options.vnicc.cur_chars = 0;
|
2017-09-18 22:18:15 +03:00
|
|
|
card->options.vnicc.wanted_chars = QETH_VNICC_DEFAULT;
|
|
|
|
return;
|
s390/qeth: add basic VNICC support
VNIC Characteristics (VNICC) are features of HiperSockets that define
how packets are handled by the underlying network hardware. For example,
if the VNICC flooding is configured on a qeth device, ethernet frames to
unknown destination MAC addresses are received.
Currently, there is support for seven VNICCs: flooding, multicast
flooding, receive broadcast, learning, takeover learning, takeover
setvmac, bridge invisible. Also, six IPA commands exist for configuring
VNICCs on a qeth device: query characteristics, query commands, enable
characteristic, disable characteristic, set timeout, get timeout.
This patch adds the basic code infrastructure for VNICC support to qeth.
It allows querying VNICC support from the underlying hardware. To this
end, it adds:
* basic message formats for IPA commands
* basic data structures
* basic error handling
* query characteristics IPA command support
The query characteristics IPA command allows requesting the currently
supported and currently enabled VNIC characteristics from the underlying
hardware.
Support for the other IPA commands and for the configuration of VNICCs
is added in follow-up patches together with the respective user
interface functions.
Signed-off-by: Hans Wippel <hwippel@linux.vnet.ibm.com>
Reviewed-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-09-18 22:18:14 +03:00
|
|
|
}
|
2017-09-18 22:18:15 +03:00
|
|
|
/* get supported commands for each supported characteristic */
|
|
|
|
chars_tmp = card->options.vnicc.sup_chars;
|
|
|
|
chars_len = sizeof(card->options.vnicc.sup_chars) * BITS_PER_BYTE;
|
|
|
|
for_each_set_bit(i, &chars_tmp, chars_len) {
|
|
|
|
vnicc = BIT(i);
|
2019-10-08 19:21:06 +03:00
|
|
|
if (qeth_l2_vnicc_query_cmds(card, vnicc, &sup_cmds)) {
|
|
|
|
sup_cmds = 0;
|
|
|
|
error = true;
|
|
|
|
}
|
2019-10-08 19:21:07 +03:00
|
|
|
if ((sup_cmds & IPA_VNICC_SET_TIMEOUT) &&
|
|
|
|
(sup_cmds & IPA_VNICC_GET_TIMEOUT))
|
|
|
|
card->options.vnicc.getset_timeout_sup |= vnicc;
|
|
|
|
else
|
2017-09-18 22:18:16 +03:00
|
|
|
card->options.vnicc.getset_timeout_sup &= ~vnicc;
|
2019-10-08 19:21:07 +03:00
|
|
|
if ((sup_cmds & IPA_VNICC_ENABLE) &&
|
|
|
|
(sup_cmds & IPA_VNICC_DISABLE))
|
|
|
|
card->options.vnicc.set_char_sup |= vnicc;
|
|
|
|
else
|
2017-09-18 22:18:15 +03:00
|
|
|
card->options.vnicc.set_char_sup &= ~vnicc;
|
|
|
|
}
|
|
|
|
/* enforce assumed default values and recover settings, if changed */
|
2019-10-08 19:21:06 +03:00
|
|
|
error |= qeth_l2_vnicc_recover_timeout(card, QETH_VNICC_LEARNING,
|
|
|
|
timeout);
|
2019-12-23 17:03:25 +03:00
|
|
|
/* Change chars, if necessary */
|
|
|
|
chars_tmp = card->options.vnicc.wanted_chars ^
|
|
|
|
card->options.vnicc.cur_chars;
|
2017-09-18 22:18:15 +03:00
|
|
|
chars_len = sizeof(card->options.vnicc.wanted_chars) * BITS_PER_BYTE;
|
|
|
|
for_each_set_bit(i, &chars_tmp, chars_len) {
|
|
|
|
vnicc = BIT(i);
|
|
|
|
enable = card->options.vnicc.wanted_chars & vnicc;
|
|
|
|
error |= qeth_l2_vnicc_recover_char(card, vnicc, enable);
|
|
|
|
}
|
|
|
|
if (error)
|
|
|
|
dev_err(&card->gdev->dev, "Configuring the VNIC characteristics failed\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
/* configure default values of VNIC characteristics */
|
|
|
|
static void qeth_l2_vnicc_set_defaults(struct qeth_card *card)
|
|
|
|
{
|
|
|
|
/* characteristics values */
|
|
|
|
card->options.vnicc.sup_chars = QETH_VNICC_ALL;
|
|
|
|
card->options.vnicc.cur_chars = QETH_VNICC_DEFAULT;
|
2017-09-18 22:18:16 +03:00
|
|
|
card->options.vnicc.learning_timeout = QETH_VNICC_DEFAULT_TIMEOUT;
|
2017-09-18 22:18:15 +03:00
|
|
|
/* supported commands */
|
|
|
|
card->options.vnicc.set_char_sup = QETH_VNICC_ALL;
|
2017-09-18 22:18:16 +03:00
|
|
|
card->options.vnicc.getset_timeout_sup = QETH_VNICC_LEARNING;
|
2017-09-18 22:18:15 +03:00
|
|
|
/* settings wanted by users */
|
|
|
|
card->options.vnicc.wanted_chars = QETH_VNICC_DEFAULT;
|
s390/qeth: add basic VNICC support
VNIC Characteristics (VNICC) are features of HiperSockets that define
how packets are handled by the underlying network hardware. For example,
if the VNICC flooding is configured on a qeth device, ethernet frames to
unknown destination MAC addresses are received.
Currently, there is support for seven VNICCs: flooding, multicast
flooding, receive broadcast, learning, takeover learning, takeover
setvmac, bridge invisible. Also, six IPA commands exist for configuring
VNICCs on a qeth device: query characteristics, query commands, enable
characteristic, disable characteristic, set timeout, get timeout.
This patch adds the basic code infrastructure for VNICC support to qeth.
It allows querying VNICC support from the underlying hardware. To this
end, it adds:
* basic message formats for IPA commands
* basic data structures
* basic error handling
* query characteristics IPA command support
The query characteristics IPA command allows requesting the currently
supported and currently enabled VNIC characteristics from the underlying
hardware.
Support for the other IPA commands and for the configuration of VNICCs
is added in follow-up patches together with the respective user
interface functions.
Signed-off-by: Hans Wippel <hwippel@linux.vnet.ibm.com>
Reviewed-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: Julian Wiedmann <jwi@linux.vnet.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-09-18 22:18:14 +03:00
|
|
|
}
|
|
|
|
|
2008-02-15 11:19:42 +03:00
|
|
|
module_init(qeth_l2_init);
|
|
|
|
module_exit(qeth_l2_exit);
|
|
|
|
MODULE_AUTHOR("Frank Blaschka <frank.blaschka@de.ibm.com>");
|
|
|
|
MODULE_DESCRIPTION("qeth layer 2 discipline");
|
|
|
|
MODULE_LICENSE("GPL");
|