summaryrefslogtreecommitdiff
path: root/drivers/s390/net
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/s390/net')
-rw-r--r--drivers/s390/net/Kconfig15
-rw-r--r--drivers/s390/net/Makefile1
-rw-r--r--drivers/s390/net/ctcm_mpc.c1
-rw-r--r--drivers/s390/net/fsm.c1
-rw-r--r--drivers/s390/net/ism.h53
-rw-r--r--drivers/s390/net/ism_drv.c577
-rw-r--r--drivers/s390/net/netiucv.c2083
-rw-r--r--drivers/s390/net/qeth_core_main.c1
-rw-r--r--drivers/s390/net/qeth_core_sys.c22
-rw-r--r--drivers/s390/net/qeth_l2_main.c1
-rw-r--r--drivers/s390/net/qeth_l3_main.c1
-rw-r--r--drivers/s390/net/smsgiucv.c1
12 files changed, 282 insertions, 2475 deletions
diff --git a/drivers/s390/net/Kconfig b/drivers/s390/net/Kconfig
index 9eb9e3c49f81..0fd700c5745a 100644
--- a/drivers/s390/net/Kconfig
+++ b/drivers/s390/net/Kconfig
@@ -17,18 +17,6 @@ config CTCM
To compile into the kernel, choose Y.
If you do not need any channel-to-channel connection, choose N.
-config NETIUCV
- def_tristate m
- prompt "IUCV network device support (VM only)"
- depends on IUCV && NETDEVICES
- help
- Select this option if you want to use inter-user communication
- vehicle networking under VM or VIF. It enables a fast communication
- link between VM guests. Using ifconfig a point-to-point connection
- can be established to the Linux on IBM System z
- running on the other VM guest. To compile as a module, choose M.
- The module name is netiucv. If unsure, choose Y.
-
config SMSGIUCV
def_tristate m
prompt "IUCV special message support (VM only)"
@@ -93,8 +81,7 @@ config CCWGROUP
config ISM
tristate "Support for ISM vPCI Adapter"
- depends on PCI
- imply SMC
+ depends on PCI && DIBS
default n
help
Select this option if you want to use the Internal Shared Memory
diff --git a/drivers/s390/net/Makefile b/drivers/s390/net/Makefile
index b5aaba290127..537514cc52fb 100644
--- a/drivers/s390/net/Makefile
+++ b/drivers/s390/net/Makefile
@@ -5,7 +5,6 @@
ctcm-y += ctcm_main.o ctcm_fsms.o ctcm_mpc.o ctcm_sysfs.o ctcm_dbug.o
obj-$(CONFIG_CTCM) += ctcm.o fsm.o
-obj-$(CONFIG_NETIUCV) += netiucv.o fsm.o
obj-$(CONFIG_SMSGIUCV) += smsgiucv.o
obj-$(CONFIG_SMSGIUCV_EVENT) += smsgiucv_app.o
qeth-y += qeth_core_sys.o qeth_core_main.o qeth_core_mpc.o qeth_ethtool.o
diff --git a/drivers/s390/net/ctcm_mpc.c b/drivers/s390/net/ctcm_mpc.c
index aaa1eea6149b..0aeafa772fb1 100644
--- a/drivers/s390/net/ctcm_mpc.c
+++ b/drivers/s390/net/ctcm_mpc.c
@@ -21,6 +21,7 @@
#define KMSG_COMPONENT "ctcm"
#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
+#include <linux/export.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
diff --git a/drivers/s390/net/fsm.c b/drivers/s390/net/fsm.c
index 6a12d2422540..58f8e2fb6d54 100644
--- a/drivers/s390/net/fsm.c
+++ b/drivers/s390/net/fsm.c
@@ -5,6 +5,7 @@
*/
#include "fsm.h"
+#include <linux/export.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/timer.h>
diff --git a/drivers/s390/net/ism.h b/drivers/s390/net/ism.h
index 047fa6101555..08d17956cb36 100644
--- a/drivers/s390/net/ism.h
+++ b/drivers/s390/net/ism.h
@@ -5,11 +5,13 @@
#include <linux/spinlock.h>
#include <linux/types.h>
#include <linux/pci.h>
-#include <linux/ism.h>
-#include <net/smc.h>
+#include <linux/dibs.h>
#include <asm/pci_insn.h>
#define UTIL_STR_LEN 16
+#define ISM_ERROR 0xFFFF
+
+#define ISM_NR_DMBS 1920
/*
* Do not use the first word of the DMB bits to ensure 8 byte aligned access.
@@ -32,6 +34,23 @@
#define ISM_UNREG_SBA 0x11
#define ISM_UNREG_IEQ 0x12
+enum ism_event_type {
+ ISM_EVENT_BUF = 0x00,
+ ISM_EVENT_DEV = 0x01,
+ ISM_EVENT_SWR = 0x02
+};
+
+enum ism_event_code {
+ ISM_BUF_DMB_UNREGISTERED = 0x04,
+ ISM_BUF_USING_ISM_DEV_DISABLED = 0x08,
+ ISM_BUF_OWNING_ISM_DEV_IN_ERR_STATE = 0x02,
+ ISM_BUF_USING_ISM_DEV_IN_ERR_STATE = 0x03,
+ ISM_BUF_VLAN_MISMATCH_WITH_OWNER = 0x05,
+ ISM_BUF_VLAN_MISMATCH_WITH_USER = 0x06,
+ ISM_DEV_GID_DISABLED = 0x07,
+ ISM_DEV_GID_ERR_STATE = 0x01
+};
+
struct ism_req_hdr {
u32 cmd;
u16 : 16;
@@ -65,6 +84,15 @@ union ism_reg_ieq {
} response;
} __aligned(16);
+/* ISM-vPCI devices provide 64 Bit GIDs
+ * Map them to ISM UUID GIDs like this:
+ * _________________________________________
+ * | 64 Bit ISM-vPCI GID | 00000000_00000000 |
+ * -----------------------------------------
+ * This will be interpreted as a UIID variant, that is reserved
+ * for NCS backward compatibility. So it will not collide with
+ * proper UUIDs.
+ */
union ism_read_gid {
struct {
struct ism_req_hdr hdr;
@@ -174,6 +202,14 @@ struct ism_eq_header {
u64 : 64;
};
+struct ism_event {
+ u32 type;
+ u32 code;
+ u64 tok;
+ u64 time;
+ u64 info;
+};
+
struct ism_eq {
struct ism_eq_header header;
struct ism_event entry[15];
@@ -188,6 +224,19 @@ struct ism_sba {
u16 dmbe_mask[ISM_NR_DMBS];
};
+struct ism_dev {
+ spinlock_t cmd_lock; /* serializes cmds */
+ struct dibs_dev *dibs;
+ struct pci_dev *pdev;
+ struct ism_sba *sba;
+ dma_addr_t sba_dma_addr;
+ DECLARE_BITMAP(sba_bitmap, ISM_NR_DMBS);
+
+ struct ism_eq *ieq;
+ dma_addr_t ieq_dma_addr;
+ int ieq_idx;
+};
+
#define ISM_CREATE_REQ(dmb, idx, sf, offset) \
((dmb) | (idx) << 24 | (sf) << 23 | (offset))
diff --git a/drivers/s390/net/ism_drv.c b/drivers/s390/net/ism_drv.c
index b7f15f303ea2..f84aa2e676e9 100644
--- a/drivers/s390/net/ism_drv.c
+++ b/drivers/s390/net/ism_drv.c
@@ -7,6 +7,7 @@
#define KMSG_COMPONENT "ism"
#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
+#include <linux/export.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/interrupt.h>
@@ -30,106 +31,12 @@ MODULE_DEVICE_TABLE(pci, ism_device_table);
static debug_info_t *ism_debug_info;
-#define NO_CLIENT 0xff /* must be >= MAX_CLIENTS */
-static struct ism_client *clients[MAX_CLIENTS]; /* use an array rather than */
- /* a list for fast mapping */
-static u8 max_client;
-static DEFINE_MUTEX(clients_lock);
-static bool ism_v2_capable;
-struct ism_dev_list {
- struct list_head list;
- struct mutex mutex; /* protects ism device list */
-};
-
-static struct ism_dev_list ism_dev_list = {
- .list = LIST_HEAD_INIT(ism_dev_list.list),
- .mutex = __MUTEX_INITIALIZER(ism_dev_list.mutex),
-};
-
-static void ism_setup_forwarding(struct ism_client *client, struct ism_dev *ism)
-{
- unsigned long flags;
-
- spin_lock_irqsave(&ism->lock, flags);
- ism->subs[client->id] = client;
- spin_unlock_irqrestore(&ism->lock, flags);
-}
-
-int ism_register_client(struct ism_client *client)
-{
- struct ism_dev *ism;
- int i, rc = -ENOSPC;
-
- mutex_lock(&ism_dev_list.mutex);
- mutex_lock(&clients_lock);
- for (i = 0; i < MAX_CLIENTS; ++i) {
- if (!clients[i]) {
- clients[i] = client;
- client->id = i;
- if (i == max_client)
- max_client++;
- rc = 0;
- break;
- }
- }
- mutex_unlock(&clients_lock);
-
- if (i < MAX_CLIENTS) {
- /* initialize with all devices that we got so far */
- list_for_each_entry(ism, &ism_dev_list.list, list) {
- ism->priv[i] = NULL;
- client->add(ism);
- ism_setup_forwarding(client, ism);
- }
- }
- mutex_unlock(&ism_dev_list.mutex);
-
- return rc;
-}
-EXPORT_SYMBOL_GPL(ism_register_client);
-
-int ism_unregister_client(struct ism_client *client)
-{
- struct ism_dev *ism;
- unsigned long flags;
- int rc = 0;
-
- mutex_lock(&ism_dev_list.mutex);
- list_for_each_entry(ism, &ism_dev_list.list, list) {
- spin_lock_irqsave(&ism->lock, flags);
- /* Stop forwarding IRQs and events */
- ism->subs[client->id] = NULL;
- for (int i = 0; i < ISM_NR_DMBS; ++i) {
- if (ism->sba_client_arr[i] == client->id) {
- WARN(1, "%s: attempt to unregister '%s' with registered dmb(s)\n",
- __func__, client->name);
- rc = -EBUSY;
- goto err_reg_dmb;
- }
- }
- spin_unlock_irqrestore(&ism->lock, flags);
- }
- mutex_unlock(&ism_dev_list.mutex);
-
- mutex_lock(&clients_lock);
- clients[client->id] = NULL;
- if (client->id + 1 == max_client)
- max_client--;
- mutex_unlock(&clients_lock);
- return rc;
-
-err_reg_dmb:
- spin_unlock_irqrestore(&ism->lock, flags);
- mutex_unlock(&ism_dev_list.mutex);
- return rc;
-}
-EXPORT_SYMBOL_GPL(ism_unregister_client);
-
static int ism_cmd(struct ism_dev *ism, void *cmd)
{
struct ism_req_hdr *req = cmd;
struct ism_resp_hdr *resp = cmd;
+ spin_lock(&ism->cmd_lock);
__ism_write_cmd(ism, req + 1, sizeof(*req), req->len - sizeof(*req));
__ism_write_cmd(ism, req, 0, sizeof(*req));
@@ -143,6 +50,7 @@ static int ism_cmd(struct ism_dev *ism, void *cmd)
}
__ism_read_cmd(ism, resp + 1, sizeof(*resp), resp->len - sizeof(*resp));
out:
+ spin_unlock(&ism->cmd_lock);
return resp->ret;
}
@@ -270,8 +178,9 @@ static int unregister_ieq(struct ism_dev *ism)
return 0;
}
-static int ism_read_local_gid(struct ism_dev *ism)
+static int ism_read_local_gid(struct dibs_dev *dibs)
{
+ struct ism_dev *ism = dibs->drv_priv;
union ism_read_gid cmd;
int ret;
@@ -283,20 +192,43 @@ static int ism_read_local_gid(struct ism_dev *ism)
if (ret)
goto out;
- ism->local_gid = cmd.response.gid;
+ memset(&dibs->gid, 0, sizeof(dibs->gid));
+ memcpy(&dibs->gid, &cmd.response.gid, sizeof(cmd.response.gid));
out:
return ret;
}
-static void ism_free_dmb(struct ism_dev *ism, struct ism_dmb *dmb)
+static int ism_query_rgid(struct dibs_dev *dibs, const uuid_t *rgid,
+ u32 vid_valid, u32 vid)
{
- clear_bit(dmb->sba_idx, ism->sba_bitmap);
+ struct ism_dev *ism = dibs->drv_priv;
+ union ism_query_rgid cmd;
+
+ memset(&cmd, 0, sizeof(cmd));
+ cmd.request.hdr.cmd = ISM_QUERY_RGID;
+ cmd.request.hdr.len = sizeof(cmd.request);
+
+ memcpy(&cmd.request.rgid, rgid, sizeof(cmd.request.rgid));
+ cmd.request.vlan_valid = vid_valid;
+ cmd.request.vlan_id = vid;
+
+ return ism_cmd(ism, &cmd);
+}
+
+static int ism_max_dmbs(void)
+{
+ return ISM_NR_DMBS;
+}
+
+static void ism_free_dmb(struct ism_dev *ism, struct dibs_dmb *dmb)
+{
+ clear_bit(dmb->idx, ism->sba_bitmap);
dma_unmap_page(&ism->pdev->dev, dmb->dma_addr, dmb->dmb_len,
DMA_FROM_DEVICE);
folio_put(virt_to_folio(dmb->cpu_addr));
}
-static int ism_alloc_dmb(struct ism_dev *ism, struct ism_dmb *dmb)
+static int ism_alloc_dmb(struct ism_dev *ism, struct dibs_dmb *dmb)
{
struct folio *folio;
unsigned long bit;
@@ -305,16 +237,16 @@ static int ism_alloc_dmb(struct ism_dev *ism, struct ism_dmb *dmb)
if (PAGE_ALIGN(dmb->dmb_len) > dma_get_max_seg_size(&ism->pdev->dev))
return -EINVAL;
- if (!dmb->sba_idx) {
+ if (!dmb->idx) {
bit = find_next_zero_bit(ism->sba_bitmap, ISM_NR_DMBS,
ISM_DMB_BIT_OFFSET);
if (bit == ISM_NR_DMBS)
return -ENOSPC;
- dmb->sba_idx = bit;
+ dmb->idx = bit;
}
- if (dmb->sba_idx < ISM_DMB_BIT_OFFSET ||
- test_and_set_bit(dmb->sba_idx, ism->sba_bitmap))
+ if (dmb->idx < ISM_DMB_BIT_OFFSET ||
+ test_and_set_bit(dmb->idx, ism->sba_bitmap))
return -EINVAL;
folio = folio_alloc(GFP_KERNEL | __GFP_NOWARN | __GFP_NOMEMALLOC |
@@ -339,13 +271,14 @@ static int ism_alloc_dmb(struct ism_dev *ism, struct ism_dmb *dmb)
out_free:
kfree(dmb->cpu_addr);
out_bit:
- clear_bit(dmb->sba_idx, ism->sba_bitmap);
+ clear_bit(dmb->idx, ism->sba_bitmap);
return rc;
}
-int ism_register_dmb(struct ism_dev *ism, struct ism_dmb *dmb,
- struct ism_client *client)
+static int ism_register_dmb(struct dibs_dev *dibs, struct dibs_dmb *dmb,
+ struct dibs_client *client)
{
+ struct ism_dev *ism = dibs->drv_priv;
union ism_reg_dmb cmd;
unsigned long flags;
int ret;
@@ -360,10 +293,10 @@ int ism_register_dmb(struct ism_dev *ism, struct ism_dmb *dmb,
cmd.request.dmb = dmb->dma_addr;
cmd.request.dmb_len = dmb->dmb_len;
- cmd.request.sba_idx = dmb->sba_idx;
+ cmd.request.sba_idx = dmb->idx;
cmd.request.vlan_valid = dmb->vlan_valid;
cmd.request.vlan_id = dmb->vlan_id;
- cmd.request.rgid = dmb->rgid;
+ memcpy(&cmd.request.rgid, &dmb->rgid, sizeof(u64));
ret = ism_cmd(ism, &cmd);
if (ret) {
@@ -371,16 +304,16 @@ int ism_register_dmb(struct ism_dev *ism, struct ism_dmb *dmb,
goto out;
}
dmb->dmb_tok = cmd.response.dmb_tok;
- spin_lock_irqsave(&ism->lock, flags);
- ism->sba_client_arr[dmb->sba_idx - ISM_DMB_BIT_OFFSET] = client->id;
- spin_unlock_irqrestore(&ism->lock, flags);
+ spin_lock_irqsave(&dibs->lock, flags);
+ dibs->dmb_clientid_arr[dmb->idx - ISM_DMB_BIT_OFFSET] = client->id;
+ spin_unlock_irqrestore(&dibs->lock, flags);
out:
return ret;
}
-EXPORT_SYMBOL_GPL(ism_register_dmb);
-int ism_unregister_dmb(struct ism_dev *ism, struct ism_dmb *dmb)
+static int ism_unregister_dmb(struct dibs_dev *dibs, struct dibs_dmb *dmb)
{
+ struct ism_dev *ism = dibs->drv_priv;
union ism_unreg_dmb cmd;
unsigned long flags;
int ret;
@@ -391,9 +324,9 @@ int ism_unregister_dmb(struct ism_dev *ism, struct ism_dmb *dmb)
cmd.request.dmb_tok = dmb->dmb_tok;
- spin_lock_irqsave(&ism->lock, flags);
- ism->sba_client_arr[dmb->sba_idx - ISM_DMB_BIT_OFFSET] = NO_CLIENT;
- spin_unlock_irqrestore(&ism->lock, flags);
+ spin_lock_irqsave(&dibs->lock, flags);
+ dibs->dmb_clientid_arr[dmb->idx - ISM_DMB_BIT_OFFSET] = NO_DIBS_CLIENT;
+ spin_unlock_irqrestore(&dibs->lock, flags);
ret = ism_cmd(ism, &cmd);
if (ret && ret != ISM_ERROR)
@@ -403,10 +336,10 @@ int ism_unregister_dmb(struct ism_dev *ism, struct ism_dmb *dmb)
out:
return ret;
}
-EXPORT_SYMBOL_GPL(ism_unregister_dmb);
-static int ism_add_vlan_id(struct ism_dev *ism, u64 vlan_id)
+static int ism_add_vlan_id(struct dibs_dev *dibs, u64 vlan_id)
{
+ struct ism_dev *ism = dibs->drv_priv;
union ism_set_vlan_id cmd;
memset(&cmd, 0, sizeof(cmd));
@@ -418,8 +351,9 @@ static int ism_add_vlan_id(struct ism_dev *ism, u64 vlan_id)
return ism_cmd(ism, &cmd);
}
-static int ism_del_vlan_id(struct ism_dev *ism, u64 vlan_id)
+static int ism_del_vlan_id(struct dibs_dev *dibs, u64 vlan_id)
{
+ struct ism_dev *ism = dibs->drv_priv;
union ism_set_vlan_id cmd;
memset(&cmd, 0, sizeof(cmd));
@@ -431,15 +365,35 @@ static int ism_del_vlan_id(struct ism_dev *ism, u64 vlan_id)
return ism_cmd(ism, &cmd);
}
+static int ism_signal_ieq(struct dibs_dev *dibs, const uuid_t *rgid,
+ u32 trigger_irq, u32 event_code, u64 info)
+{
+ struct ism_dev *ism = dibs->drv_priv;
+ union ism_sig_ieq cmd;
+
+ memset(&cmd, 0, sizeof(cmd));
+ cmd.request.hdr.cmd = ISM_SIGNAL_IEQ;
+ cmd.request.hdr.len = sizeof(cmd.request);
+
+ memcpy(&cmd.request.rgid, rgid, sizeof(cmd.request.rgid));
+ cmd.request.trigger_irq = trigger_irq;
+ cmd.request.event_code = event_code;
+ cmd.request.info = info;
+
+ return ism_cmd(ism, &cmd);
+}
+
static unsigned int max_bytes(unsigned int start, unsigned int len,
unsigned int boundary)
{
return min(boundary - (start & (boundary - 1)), len);
}
-int ism_move(struct ism_dev *ism, u64 dmb_tok, unsigned int idx, bool sf,
- unsigned int offset, void *data, unsigned int size)
+static int ism_move(struct dibs_dev *dibs, u64 dmb_tok, unsigned int idx,
+ bool sf, unsigned int offset, void *data,
+ unsigned int size)
{
+ struct ism_dev *ism = dibs->drv_priv;
unsigned int bytes;
u64 dmb_req;
int ret;
@@ -460,24 +414,79 @@ int ism_move(struct ism_dev *ism, u64 dmb_tok, unsigned int idx, bool sf,
return 0;
}
-EXPORT_SYMBOL_GPL(ism_move);
+
+static u16 ism_get_chid(struct dibs_dev *dibs)
+{
+ struct ism_dev *ism = dibs->drv_priv;
+
+ if (!ism || !ism->pdev)
+ return 0;
+
+ return to_zpci(ism->pdev)->pchid;
+}
+
+static int ism_match_event_type(u32 s390_event_type)
+{
+ switch (s390_event_type) {
+ case ISM_EVENT_BUF:
+ return DIBS_BUF_EVENT;
+ case ISM_EVENT_DEV:
+ return DIBS_DEV_EVENT;
+ case ISM_EVENT_SWR:
+ return DIBS_SW_EVENT;
+ default:
+ return DIBS_OTHER_TYPE;
+ }
+}
+
+static int ism_match_event_subtype(u32 s390_event_subtype)
+{
+ switch (s390_event_subtype) {
+ case ISM_BUF_DMB_UNREGISTERED:
+ return DIBS_BUF_UNREGISTERED;
+ case ISM_DEV_GID_DISABLED:
+ return DIBS_DEV_DISABLED;
+ case ISM_DEV_GID_ERR_STATE:
+ return DIBS_DEV_ERR_STATE;
+ default:
+ return DIBS_OTHER_SUBTYPE;
+ }
+}
static void ism_handle_event(struct ism_dev *ism)
{
+ struct dibs_dev *dibs = ism->dibs;
+ struct dibs_event event;
struct ism_event *entry;
- struct ism_client *clt;
+ struct dibs_client *clt;
int i;
while ((ism->ieq_idx + 1) != READ_ONCE(ism->ieq->header.idx)) {
- if (++(ism->ieq_idx) == ARRAY_SIZE(ism->ieq->entry))
+ if (++ism->ieq_idx == ARRAY_SIZE(ism->ieq->entry))
ism->ieq_idx = 0;
entry = &ism->ieq->entry[ism->ieq_idx];
debug_event(ism_debug_info, 2, entry, sizeof(*entry));
- for (i = 0; i < max_client; ++i) {
- clt = ism->subs[i];
+ __memset(&event, 0, sizeof(event));
+ event.type = ism_match_event_type(entry->type);
+ if (event.type == DIBS_SW_EVENT)
+ event.subtype = entry->code;
+ else
+ event.subtype = ism_match_event_subtype(entry->code);
+ event.time = entry->time;
+ event.data = entry->info;
+ switch (event.type) {
+ case DIBS_BUF_EVENT:
+ event.buffer_tok = entry->tok;
+ break;
+ case DIBS_DEV_EVENT:
+ case DIBS_SW_EVENT:
+ memcpy(&event.gid, &entry->tok, sizeof(u64));
+ }
+ for (i = 0; i < MAX_DIBS_CLIENTS; ++i) {
+ clt = dibs->subs[i];
if (clt)
- clt->handle_event(ism, entry);
+ clt->ops->handle_event(dibs, &event);
}
}
}
@@ -486,14 +495,17 @@ static irqreturn_t ism_handle_irq(int irq, void *data)
{
struct ism_dev *ism = data;
unsigned long bit, end;
+ struct dibs_dev *dibs;
unsigned long *bv;
u16 dmbemask;
u8 client_id;
+ dibs = ism->dibs;
+
bv = (void *) &ism->sba->dmb_bits[ISM_DMB_WORD_OFFSET];
end = sizeof(ism->sba->dmb_bits) * BITS_PER_BYTE - ISM_DMB_BIT_OFFSET;
- spin_lock(&ism->lock);
+ spin_lock(&dibs->lock);
ism->sba->s = 0;
barrier();
for (bit = 0;;) {
@@ -505,10 +517,13 @@ static irqreturn_t ism_handle_irq(int irq, void *data)
dmbemask = ism->sba->dmbe_mask[bit + ISM_DMB_BIT_OFFSET];
ism->sba->dmbe_mask[bit + ISM_DMB_BIT_OFFSET] = 0;
barrier();
- client_id = ism->sba_client_arr[bit];
- if (unlikely(client_id == NO_CLIENT || !ism->subs[client_id]))
+ client_id = dibs->dmb_clientid_arr[bit];
+ if (unlikely(client_id == NO_DIBS_CLIENT ||
+ !dibs->subs[client_id]))
continue;
- ism->subs[client_id]->handle_irq(ism, bit + ISM_DMB_BIT_OFFSET, dmbemask);
+ dibs->subs[client_id]->ops->handle_irq(dibs,
+ bit + ISM_DMB_BIT_OFFSET,
+ dmbemask);
}
if (ism->sba->e) {
@@ -516,28 +531,35 @@ static irqreturn_t ism_handle_irq(int irq, void *data)
barrier();
ism_handle_event(ism);
}
- spin_unlock(&ism->lock);
+ spin_unlock(&dibs->lock);
return IRQ_HANDLED;
}
+static const struct dibs_dev_ops ism_ops = {
+ .get_fabric_id = ism_get_chid,
+ .query_remote_gid = ism_query_rgid,
+ .max_dmbs = ism_max_dmbs,
+ .register_dmb = ism_register_dmb,
+ .unregister_dmb = ism_unregister_dmb,
+ .move_data = ism_move,
+ .add_vlan_id = ism_add_vlan_id,
+ .del_vlan_id = ism_del_vlan_id,
+ .signal_event = ism_signal_ieq,
+};
+
static int ism_dev_init(struct ism_dev *ism)
{
struct pci_dev *pdev = ism->pdev;
- int i, ret;
+ int ret;
ret = pci_alloc_irq_vectors(pdev, 1, 1, PCI_IRQ_MSI);
if (ret <= 0)
goto out;
- ism->sba_client_arr = kzalloc(ISM_NR_DMBS, GFP_KERNEL);
- if (!ism->sba_client_arr)
- goto free_vectors;
- memset(ism->sba_client_arr, NO_CLIENT, ISM_NR_DMBS);
-
ret = request_irq(pci_irq_vector(pdev, 0), ism_handle_irq, 0,
pci_name(pdev), ism);
if (ret)
- goto free_client_arr;
+ goto free_vectors;
ret = register_sba(ism);
if (ret)
@@ -547,57 +569,33 @@ static int ism_dev_init(struct ism_dev *ism)
if (ret)
goto unreg_sba;
- ret = ism_read_local_gid(ism);
- if (ret)
- goto unreg_ieq;
-
- if (!ism_add_vlan_id(ism, ISM_RESERVED_VLANID))
- /* hardware is V2 capable */
- ism_v2_capable = true;
- else
- ism_v2_capable = false;
-
- mutex_lock(&ism_dev_list.mutex);
- mutex_lock(&clients_lock);
- for (i = 0; i < max_client; ++i) {
- if (clients[i]) {
- clients[i]->add(ism);
- ism_setup_forwarding(clients[i], ism);
- }
- }
- mutex_unlock(&clients_lock);
-
- list_add(&ism->list, &ism_dev_list.list);
- mutex_unlock(&ism_dev_list.mutex);
-
query_info(ism);
return 0;
-unreg_ieq:
- unregister_ieq(ism);
unreg_sba:
unregister_sba(ism);
free_irq:
free_irq(pci_irq_vector(pdev, 0), ism);
-free_client_arr:
- kfree(ism->sba_client_arr);
free_vectors:
pci_free_irq_vectors(pdev);
out:
return ret;
}
-static void ism_dev_release(struct device *dev)
+static void ism_dev_exit(struct ism_dev *ism)
{
- struct ism_dev *ism;
-
- ism = container_of(dev, struct ism_dev, dev);
+ struct pci_dev *pdev = ism->pdev;
- kfree(ism);
+ unregister_ieq(ism);
+ unregister_sba(ism);
+ free_irq(pci_irq_vector(pdev, 0), ism);
+ pci_free_irq_vectors(pdev);
}
static int ism_probe(struct pci_dev *pdev, const struct pci_device_id *id)
{
+ struct dibs_dev *dibs;
+ struct zpci_dev *zdev;
struct ism_dev *ism;
int ret;
@@ -605,20 +603,13 @@ static int ism_probe(struct pci_dev *pdev, const struct pci_device_id *id)
if (!ism)
return -ENOMEM;
- spin_lock_init(&ism->lock);
+ spin_lock_init(&ism->cmd_lock);
dev_set_drvdata(&pdev->dev, ism);
ism->pdev = pdev;
- ism->dev.parent = &pdev->dev;
- ism->dev.release = ism_dev_release;
- device_initialize(&ism->dev);
- dev_set_name(&ism->dev, "%s", dev_name(&pdev->dev));
- ret = device_add(&ism->dev);
- if (ret)
- goto err_dev;
ret = pci_enable_device_mem(pdev);
if (ret)
- goto err;
+ goto err_dev;
ret = pci_request_mem_regions(pdev, DRV_NAME);
if (ret)
@@ -632,66 +623,69 @@ static int ism_probe(struct pci_dev *pdev, const struct pci_device_id *id)
dma_set_max_seg_size(&pdev->dev, SZ_1M);
pci_set_master(pdev);
+ dibs = dibs_dev_alloc();
+ if (!dibs) {
+ ret = -ENOMEM;
+ goto err_resource;
+ }
+ /* set this up before we enable interrupts */
+ ism->dibs = dibs;
+ dibs->drv_priv = ism;
+ dibs->ops = &ism_ops;
+
+ /* enable ism device, but any interrupts and events will be ignored
+ * before dibs_dev_add() adds it to any clients.
+ */
ret = ism_dev_init(ism);
if (ret)
- goto err_resource;
+ goto err_dibs;
+
+ /* after ism_dev_init() we can call ism function to set gid */
+ ret = ism_read_local_gid(dibs);
+ if (ret)
+ goto err_ism;
+
+ dibs->dev.parent = &pdev->dev;
+
+ zdev = to_zpci(pdev);
+ dev_set_name(&dibs->dev, "ism%x", zdev->uid ? zdev->uid : zdev->fid);
+
+ ret = dibs_dev_add(dibs);
+ if (ret)
+ goto err_ism;
return 0;
+err_ism:
+ ism_dev_exit(ism);
+err_dibs:
+ /* pairs with dibs_dev_alloc() */
+ put_device(&dibs->dev);
err_resource:
pci_release_mem_regions(pdev);
err_disable:
pci_disable_device(pdev);
-err:
- device_del(&ism->dev);
err_dev:
dev_set_drvdata(&pdev->dev, NULL);
- put_device(&ism->dev);
+ kfree(ism);
return ret;
}
-static void ism_dev_exit(struct ism_dev *ism)
-{
- struct pci_dev *pdev = ism->pdev;
- unsigned long flags;
- int i;
-
- spin_lock_irqsave(&ism->lock, flags);
- for (i = 0; i < max_client; ++i)
- ism->subs[i] = NULL;
- spin_unlock_irqrestore(&ism->lock, flags);
-
- mutex_lock(&ism_dev_list.mutex);
- mutex_lock(&clients_lock);
- for (i = 0; i < max_client; ++i) {
- if (clients[i])
- clients[i]->remove(ism);
- }
- mutex_unlock(&clients_lock);
-
- if (ism_v2_capable)
- ism_del_vlan_id(ism, ISM_RESERVED_VLANID);
- unregister_ieq(ism);
- unregister_sba(ism);
- free_irq(pci_irq_vector(pdev, 0), ism);
- kfree(ism->sba_client_arr);
- pci_free_irq_vectors(pdev);
- list_del_init(&ism->list);
- mutex_unlock(&ism_dev_list.mutex);
-}
-
static void ism_remove(struct pci_dev *pdev)
{
struct ism_dev *ism = dev_get_drvdata(&pdev->dev);
+ struct dibs_dev *dibs = ism->dibs;
+ dibs_dev_del(dibs);
ism_dev_exit(ism);
+ /* pairs with dibs_dev_alloc() */
+ put_device(&dibs->dev);
pci_release_mem_regions(pdev);
pci_disable_device(pdev);
- device_del(&ism->dev);
dev_set_drvdata(&pdev->dev, NULL);
- put_device(&ism->dev);
+ kfree(ism);
}
static struct pci_driver ism_driver = {
@@ -709,8 +703,6 @@ static int __init ism_init(void)
if (!ism_debug_info)
return -ENODEV;
- memset(clients, 0, sizeof(clients));
- max_client = 0;
debug_register_view(ism_debug_info, &debug_hex_ascii_view);
ret = pci_register_driver(&ism_driver);
if (ret)
@@ -727,150 +719,3 @@ static void __exit ism_exit(void)
module_init(ism_init);
module_exit(ism_exit);
-
-/*************************** SMC-D Implementation *****************************/
-
-#if IS_ENABLED(CONFIG_SMC)
-static int ism_query_rgid(struct ism_dev *ism, u64 rgid, u32 vid_valid,
- u32 vid)
-{
- union ism_query_rgid cmd;
-
- memset(&cmd, 0, sizeof(cmd));
- cmd.request.hdr.cmd = ISM_QUERY_RGID;
- cmd.request.hdr.len = sizeof(cmd.request);
-
- cmd.request.rgid = rgid;
- cmd.request.vlan_valid = vid_valid;
- cmd.request.vlan_id = vid;
-
- return ism_cmd(ism, &cmd);
-}
-
-static int smcd_query_rgid(struct smcd_dev *smcd, struct smcd_gid *rgid,
- u32 vid_valid, u32 vid)
-{
- return ism_query_rgid(smcd->priv, rgid->gid, vid_valid, vid);
-}
-
-static int smcd_register_dmb(struct smcd_dev *smcd, struct smcd_dmb *dmb,
- void *client)
-{
- return ism_register_dmb(smcd->priv, (struct ism_dmb *)dmb, client);
-}
-
-static int smcd_unregister_dmb(struct smcd_dev *smcd, struct smcd_dmb *dmb)
-{
- return ism_unregister_dmb(smcd->priv, (struct ism_dmb *)dmb);
-}
-
-static int smcd_add_vlan_id(struct smcd_dev *smcd, u64 vlan_id)
-{
- return ism_add_vlan_id(smcd->priv, vlan_id);
-}
-
-static int smcd_del_vlan_id(struct smcd_dev *smcd, u64 vlan_id)
-{
- return ism_del_vlan_id(smcd->priv, vlan_id);
-}
-
-static int smcd_set_vlan_required(struct smcd_dev *smcd)
-{
- return ism_cmd_simple(smcd->priv, ISM_SET_VLAN);
-}
-
-static int smcd_reset_vlan_required(struct smcd_dev *smcd)
-{
- return ism_cmd_simple(smcd->priv, ISM_RESET_VLAN);
-}
-
-static int ism_signal_ieq(struct ism_dev *ism, u64 rgid, u32 trigger_irq,
- u32 event_code, u64 info)
-{
- union ism_sig_ieq cmd;
-
- memset(&cmd, 0, sizeof(cmd));
- cmd.request.hdr.cmd = ISM_SIGNAL_IEQ;
- cmd.request.hdr.len = sizeof(cmd.request);
-
- cmd.request.rgid = rgid;
- cmd.request.trigger_irq = trigger_irq;
- cmd.request.event_code = event_code;
- cmd.request.info = info;
-
- return ism_cmd(ism, &cmd);
-}
-
-static int smcd_signal_ieq(struct smcd_dev *smcd, struct smcd_gid *rgid,
- u32 trigger_irq, u32 event_code, u64 info)
-{
- return ism_signal_ieq(smcd->priv, rgid->gid,
- trigger_irq, event_code, info);
-}
-
-static int smcd_move(struct smcd_dev *smcd, u64 dmb_tok, unsigned int idx,
- bool sf, unsigned int offset, void *data,
- unsigned int size)
-{
- return ism_move(smcd->priv, dmb_tok, idx, sf, offset, data, size);
-}
-
-static int smcd_supports_v2(void)
-{
- return ism_v2_capable;
-}
-
-static u64 ism_get_local_gid(struct ism_dev *ism)
-{
- return ism->local_gid;
-}
-
-static void smcd_get_local_gid(struct smcd_dev *smcd,
- struct smcd_gid *smcd_gid)
-{
- smcd_gid->gid = ism_get_local_gid(smcd->priv);
- smcd_gid->gid_ext = 0;
-}
-
-static u16 ism_get_chid(struct ism_dev *ism)
-{
- if (!ism || !ism->pdev)
- return 0;
-
- return to_zpci(ism->pdev)->pchid;
-}
-
-static u16 smcd_get_chid(struct smcd_dev *smcd)
-{
- return ism_get_chid(smcd->priv);
-}
-
-static inline struct device *smcd_get_dev(struct smcd_dev *dev)
-{
- struct ism_dev *ism = dev->priv;
-
- return &ism->dev;
-}
-
-static const struct smcd_ops ism_ops = {
- .query_remote_gid = smcd_query_rgid,
- .register_dmb = smcd_register_dmb,
- .unregister_dmb = smcd_unregister_dmb,
- .add_vlan_id = smcd_add_vlan_id,
- .del_vlan_id = smcd_del_vlan_id,
- .set_vlan_required = smcd_set_vlan_required,
- .reset_vlan_required = smcd_reset_vlan_required,
- .signal_event = smcd_signal_ieq,
- .move_data = smcd_move,
- .supports_v2 = smcd_supports_v2,
- .get_local_gid = smcd_get_local_gid,
- .get_chid = smcd_get_chid,
- .get_dev = smcd_get_dev,
-};
-
-const struct smcd_ops *ism_get_smcd_ops(void)
-{
- return &ism_ops;
-}
-EXPORT_SYMBOL_GPL(ism_get_smcd_ops);
-#endif
diff --git a/drivers/s390/net/netiucv.c b/drivers/s390/net/netiucv.c
deleted file mode 100644
index 31c9f95d809d..000000000000
--- a/drivers/s390/net/netiucv.c
+++ /dev/null
@@ -1,2083 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0+
-/*
- * IUCV network driver
- *
- * Copyright IBM Corp. 2001, 2009
- *
- * Author(s):
- * Original netiucv driver:
- * Fritz Elfert (elfert@de.ibm.com, felfert@millenux.com)
- * Sysfs integration and all bugs therein:
- * Cornelia Huck (cornelia.huck@de.ibm.com)
- * PM functions:
- * Ursula Braun (ursula.braun@de.ibm.com)
- *
- * Documentation used:
- * the source of the original IUCV driver by:
- * Stefan Hegewald <hegewald@de.ibm.com>
- * Hartmut Penner <hpenner@de.ibm.com>
- * Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
- * Martin Schwidefsky (schwidefsky@de.ibm.com)
- * Alan Altmark (Alan_Altmark@us.ibm.com) Sept. 2000
- */
-
-#define KMSG_COMPONENT "netiucv"
-#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
-
-#undef DEBUG
-
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/kernel.h>
-#include <linux/slab.h>
-#include <linux/errno.h>
-#include <linux/types.h>
-#include <linux/interrupt.h>
-#include <linux/timer.h>
-#include <linux/bitops.h>
-
-#include <linux/signal.h>
-#include <linux/string.h>
-#include <linux/device.h>
-
-#include <linux/ip.h>
-#include <linux/if_arp.h>
-#include <linux/tcp.h>
-#include <linux/skbuff.h>
-#include <linux/ctype.h>
-#include <net/dst.h>
-
-#include <linux/io.h>
-#include <linux/uaccess.h>
-#include <asm/ebcdic.h>
-
-#include <net/iucv/iucv.h>
-#include "fsm.h"
-
-MODULE_AUTHOR
- ("(C) 2001 IBM Corporation by Fritz Elfert (felfert@millenux.com)");
-MODULE_DESCRIPTION ("Linux for S/390 IUCV network driver");
-
-/*
- * Debug Facility stuff
- */
-#define IUCV_DBF_SETUP_NAME "iucv_setup"
-#define IUCV_DBF_SETUP_LEN 64
-#define IUCV_DBF_SETUP_PAGES 2
-#define IUCV_DBF_SETUP_NR_AREAS 1
-#define IUCV_DBF_SETUP_LEVEL 3
-
-#define IUCV_DBF_DATA_NAME "iucv_data"
-#define IUCV_DBF_DATA_LEN 128
-#define IUCV_DBF_DATA_PAGES 2
-#define IUCV_DBF_DATA_NR_AREAS 1
-#define IUCV_DBF_DATA_LEVEL 2
-
-#define IUCV_DBF_TRACE_NAME "iucv_trace"
-#define IUCV_DBF_TRACE_LEN 16
-#define IUCV_DBF_TRACE_PAGES 4
-#define IUCV_DBF_TRACE_NR_AREAS 1
-#define IUCV_DBF_TRACE_LEVEL 3
-
-#define IUCV_DBF_TEXT(name,level,text) \
- do { \
- debug_text_event(iucv_dbf_##name,level,text); \
- } while (0)
-
-#define IUCV_DBF_HEX(name,level,addr,len) \
- do { \
- debug_event(iucv_dbf_##name,level,(void*)(addr),len); \
- } while (0)
-
-DECLARE_PER_CPU(char[256], iucv_dbf_txt_buf);
-
-#define IUCV_DBF_TEXT_(name, level, text...) \
- do { \
- if (debug_level_enabled(iucv_dbf_##name, level)) { \
- char* __buf = get_cpu_var(iucv_dbf_txt_buf); \
- sprintf(__buf, text); \
- debug_text_event(iucv_dbf_##name, level, __buf); \
- put_cpu_var(iucv_dbf_txt_buf); \
- } \
- } while (0)
-
-#define IUCV_DBF_SPRINTF(name,level,text...) \
- do { \
- debug_sprintf_event(iucv_dbf_trace, level, ##text ); \
- debug_sprintf_event(iucv_dbf_trace, level, text ); \
- } while (0)
-
-/*
- * some more debug stuff
- */
-#define PRINTK_HEADER " iucv: " /* for debugging */
-
-static struct device_driver netiucv_driver = {
- .owner = THIS_MODULE,
- .name = "netiucv",
- .bus = &iucv_bus,
-};
-
-/*
- * Per connection profiling data
- */
-struct connection_profile {
- unsigned long maxmulti;
- unsigned long maxcqueue;
- unsigned long doios_single;
- unsigned long doios_multi;
- unsigned long txlen;
- unsigned long tx_time;
- unsigned long send_stamp;
- unsigned long tx_pending;
- unsigned long tx_max_pending;
-};
-
-/*
- * Representation of one iucv connection
- */
-struct iucv_connection {
- struct list_head list;
- struct iucv_path *path;
- struct sk_buff *rx_buff;
- struct sk_buff *tx_buff;
- struct sk_buff_head collect_queue;
- struct sk_buff_head commit_queue;
- spinlock_t collect_lock;
- int collect_len;
- int max_buffsize;
- fsm_timer timer;
- fsm_instance *fsm;
- struct net_device *netdev;
- struct connection_profile prof;
- char userid[9];
- char userdata[17];
-};
-
-/*
- * Linked list of all connection structs.
- */
-static LIST_HEAD(iucv_connection_list);
-static DEFINE_RWLOCK(iucv_connection_rwlock);
-
-/*
- * Representation of event-data for the
- * connection state machine.
- */
-struct iucv_event {
- struct iucv_connection *conn;
- void *data;
-};
-
-/*
- * Private part of the network device structure
- */
-struct netiucv_priv {
- struct net_device_stats stats;
- unsigned long tbusy;
- fsm_instance *fsm;
- struct iucv_connection *conn;
- struct device *dev;
-};
-
-/*
- * Link level header for a packet.
- */
-struct ll_header {
- u16 next;
-};
-
-#define NETIUCV_HDRLEN (sizeof(struct ll_header))
-#define NETIUCV_BUFSIZE_MAX 65537
-#define NETIUCV_BUFSIZE_DEFAULT NETIUCV_BUFSIZE_MAX
-#define NETIUCV_MTU_MAX (NETIUCV_BUFSIZE_MAX - NETIUCV_HDRLEN)
-#define NETIUCV_MTU_DEFAULT 9216
-#define NETIUCV_QUEUELEN_DEFAULT 50
-#define NETIUCV_TIMEOUT_5SEC 5000
-
-/*
- * Compatibility macros for busy handling
- * of network devices.
- */
-static void netiucv_clear_busy(struct net_device *dev)
-{
- struct netiucv_priv *priv = netdev_priv(dev);
- clear_bit(0, &priv->tbusy);
- netif_wake_queue(dev);
-}
-
-static int netiucv_test_and_set_busy(struct net_device *dev)
-{
- struct netiucv_priv *priv = netdev_priv(dev);
- netif_stop_queue(dev);
- return test_and_set_bit(0, &priv->tbusy);
-}
-
-static u8 iucvMagic_ascii[16] = {
- 0x30, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
- 0x30, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20
-};
-
-static u8 iucvMagic_ebcdic[16] = {
- 0xF0, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
- 0xF0, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40
-};
-
-/*
- * Convert an iucv userId to its printable
- * form (strip whitespace at end).
- *
- * @param An iucv userId
- *
- * @returns The printable string (static data!!)
- */
-static char *netiucv_printname(char *name, int len)
-{
- static char tmp[17];
- char *p = tmp;
- memcpy(tmp, name, len);
- tmp[len] = '\0';
- while (*p && ((p - tmp) < len) && (!isspace(*p)))
- p++;
- *p = '\0';
- return tmp;
-}
-
-static char *netiucv_printuser(struct iucv_connection *conn)
-{
- static char tmp_uid[9];
- static char tmp_udat[17];
- static char buf[100];
-
- if (memcmp(conn->userdata, iucvMagic_ebcdic, 16)) {
- tmp_uid[8] = '\0';
- tmp_udat[16] = '\0';
- memcpy(tmp_uid, netiucv_printname(conn->userid, 8), 8);
- memcpy(tmp_udat, conn->userdata, 16);
- EBCASC(tmp_udat, 16);
- memcpy(tmp_udat, netiucv_printname(tmp_udat, 16), 16);
- sprintf(buf, "%s.%s", tmp_uid, tmp_udat);
- return buf;
- } else
- return netiucv_printname(conn->userid, 8);
-}
-
-/*
- * States of the interface statemachine.
- */
-enum dev_states {
- DEV_STATE_STOPPED,
- DEV_STATE_STARTWAIT,
- DEV_STATE_STOPWAIT,
- DEV_STATE_RUNNING,
- /*
- * MUST be always the last element!!
- */
- NR_DEV_STATES
-};
-
-static const char *dev_state_names[] = {
- "Stopped",
- "StartWait",
- "StopWait",
- "Running",
-};
-
-/*
- * Events of the interface statemachine.
- */
-enum dev_events {
- DEV_EVENT_START,
- DEV_EVENT_STOP,
- DEV_EVENT_CONUP,
- DEV_EVENT_CONDOWN,
- /*
- * MUST be always the last element!!
- */
- NR_DEV_EVENTS
-};
-
-static const char *dev_event_names[] = {
- "Start",
- "Stop",
- "Connection up",
- "Connection down",
-};
-
-/*
- * Events of the connection statemachine
- */
-enum conn_events {
- /*
- * Events, representing callbacks from
- * lowlevel iucv layer)
- */
- CONN_EVENT_CONN_REQ,
- CONN_EVENT_CONN_ACK,
- CONN_EVENT_CONN_REJ,
- CONN_EVENT_CONN_SUS,
- CONN_EVENT_CONN_RES,
- CONN_EVENT_RX,
- CONN_EVENT_TXDONE,
-
- /*
- * Events, representing errors return codes from
- * calls to lowlevel iucv layer
- */
-
- /*
- * Event, representing timer expiry.
- */
- CONN_EVENT_TIMER,
-
- /*
- * Events, representing commands from upper levels.
- */
- CONN_EVENT_START,
- CONN_EVENT_STOP,
-
- /*
- * MUST be always the last element!!
- */
- NR_CONN_EVENTS,
-};
-
-static const char *conn_event_names[] = {
- "Remote connection request",
- "Remote connection acknowledge",
- "Remote connection reject",
- "Connection suspended",
- "Connection resumed",
- "Data received",
- "Data sent",
-
- "Timer",
-
- "Start",
- "Stop",
-};
-
-/*
- * States of the connection statemachine.
- */
-enum conn_states {
- /*
- * Connection not assigned to any device,
- * initial state, invalid
- */
- CONN_STATE_INVALID,
-
- /*
- * Userid assigned but not operating
- */
- CONN_STATE_STOPPED,
-
- /*
- * Connection registered,
- * no connection request sent yet,
- * no connection request received
- */
- CONN_STATE_STARTWAIT,
-
- /*
- * Connection registered and connection request sent,
- * no acknowledge and no connection request received yet.
- */
- CONN_STATE_SETUPWAIT,
-
- /*
- * Connection up and running idle
- */
- CONN_STATE_IDLE,
-
- /*
- * Data sent, awaiting CONN_EVENT_TXDONE
- */
- CONN_STATE_TX,
-
- /*
- * Error during registration.
- */
- CONN_STATE_REGERR,
-
- /*
- * Error during registration.
- */
- CONN_STATE_CONNERR,
-
- /*
- * MUST be always the last element!!
- */
- NR_CONN_STATES,
-};
-
-static const char *conn_state_names[] = {
- "Invalid",
- "Stopped",
- "StartWait",
- "SetupWait",
- "Idle",
- "TX",
- "Terminating",
- "Registration error",
- "Connect error",
-};
-
-
-/*
- * Debug Facility Stuff
- */
-static debug_info_t *iucv_dbf_setup = NULL;
-static debug_info_t *iucv_dbf_data = NULL;
-static debug_info_t *iucv_dbf_trace = NULL;
-
-DEFINE_PER_CPU(char[256], iucv_dbf_txt_buf);
-
-static void iucv_unregister_dbf_views(void)
-{
- debug_unregister(iucv_dbf_setup);
- debug_unregister(iucv_dbf_data);
- debug_unregister(iucv_dbf_trace);
-}
-static int iucv_register_dbf_views(void)
-{
- iucv_dbf_setup = debug_register(IUCV_DBF_SETUP_NAME,
- IUCV_DBF_SETUP_PAGES,
- IUCV_DBF_SETUP_NR_AREAS,
- IUCV_DBF_SETUP_LEN);
- iucv_dbf_data = debug_register(IUCV_DBF_DATA_NAME,
- IUCV_DBF_DATA_PAGES,
- IUCV_DBF_DATA_NR_AREAS,
- IUCV_DBF_DATA_LEN);
- iucv_dbf_trace = debug_register(IUCV_DBF_TRACE_NAME,
- IUCV_DBF_TRACE_PAGES,
- IUCV_DBF_TRACE_NR_AREAS,
- IUCV_DBF_TRACE_LEN);
-
- if ((iucv_dbf_setup == NULL) || (iucv_dbf_data == NULL) ||
- (iucv_dbf_trace == NULL)) {
- iucv_unregister_dbf_views();
- return -ENOMEM;
- }
- debug_register_view(iucv_dbf_setup, &debug_hex_ascii_view);
- debug_set_level(iucv_dbf_setup, IUCV_DBF_SETUP_LEVEL);
-
- debug_register_view(iucv_dbf_data, &debug_hex_ascii_view);
- debug_set_level(iucv_dbf_data, IUCV_DBF_DATA_LEVEL);
-
- debug_register_view(iucv_dbf_trace, &debug_hex_ascii_view);
- debug_set_level(iucv_dbf_trace, IUCV_DBF_TRACE_LEVEL);
-
- return 0;
-}
-
-/*
- * Callback-wrappers, called from lowlevel iucv layer.
- */
-
-static void netiucv_callback_rx(struct iucv_path *path,
- struct iucv_message *msg)
-{
- struct iucv_connection *conn = path->private;
- struct iucv_event ev;
-
- ev.conn = conn;
- ev.data = msg;
- fsm_event(conn->fsm, CONN_EVENT_RX, &ev);
-}
-
-static void netiucv_callback_txdone(struct iucv_path *path,
- struct iucv_message *msg)
-{
- struct iucv_connection *conn = path->private;
- struct iucv_event ev;
-
- ev.conn = conn;
- ev.data = msg;
- fsm_event(conn->fsm, CONN_EVENT_TXDONE, &ev);
-}
-
-static void netiucv_callback_connack(struct iucv_path *path, u8 ipuser[16])
-{
- struct iucv_connection *conn = path->private;
-
- fsm_event(conn->fsm, CONN_EVENT_CONN_ACK, conn);
-}
-
-static int netiucv_callback_connreq(struct iucv_path *path, u8 *ipvmid,
- u8 *ipuser)
-{
- struct iucv_connection *conn = path->private;
- struct iucv_event ev;
- static char tmp_user[9];
- static char tmp_udat[17];
- int rc;
-
- rc = -EINVAL;
- memcpy(tmp_user, netiucv_printname(ipvmid, 8), 8);
- memcpy(tmp_udat, ipuser, 16);
- EBCASC(tmp_udat, 16);
- read_lock_bh(&iucv_connection_rwlock);
- list_for_each_entry(conn, &iucv_connection_list, list) {
- if (strncmp(ipvmid, conn->userid, 8) ||
- strncmp(ipuser, conn->userdata, 16))
- continue;
- /* Found a matching connection for this path. */
- conn->path = path;
- ev.conn = conn;
- ev.data = path;
- fsm_event(conn->fsm, CONN_EVENT_CONN_REQ, &ev);
- rc = 0;
- }
- IUCV_DBF_TEXT_(setup, 2, "Connection requested for %s.%s\n",
- tmp_user, netiucv_printname(tmp_udat, 16));
- read_unlock_bh(&iucv_connection_rwlock);
- return rc;
-}
-
-static void netiucv_callback_connrej(struct iucv_path *path, u8 *ipuser)
-{
- struct iucv_connection *conn = path->private;
-
- fsm_event(conn->fsm, CONN_EVENT_CONN_REJ, conn);
-}
-
-static void netiucv_callback_connsusp(struct iucv_path *path, u8 *ipuser)
-{
- struct iucv_connection *conn = path->private;
-
- fsm_event(conn->fsm, CONN_EVENT_CONN_SUS, conn);
-}
-
-static void netiucv_callback_connres(struct iucv_path *path, u8 *ipuser)
-{
- struct iucv_connection *conn = path->private;
-
- fsm_event(conn->fsm, CONN_EVENT_CONN_RES, conn);
-}
-
-/*
- * NOP action for statemachines
- */
-static void netiucv_action_nop(fsm_instance *fi, int event, void *arg)
-{
-}
-
-/*
- * Actions of the connection statemachine
- */
-
-/*
- * netiucv_unpack_skb
- * @conn: The connection where this skb has been received.
- * @pskb: The received skb.
- *
- * Unpack a just received skb and hand it over to upper layers.
- * Helper function for conn_action_rx.
- */
-static void netiucv_unpack_skb(struct iucv_connection *conn,
- struct sk_buff *pskb)
-{
- struct net_device *dev = conn->netdev;
- struct netiucv_priv *privptr = netdev_priv(dev);
- u16 offset = 0;
-
- skb_put(pskb, NETIUCV_HDRLEN);
- pskb->dev = dev;
- pskb->ip_summed = CHECKSUM_NONE;
- pskb->protocol = cpu_to_be16(ETH_P_IP);
-
- while (1) {
- struct sk_buff *skb;
- struct ll_header *header = (struct ll_header *) pskb->data;
-
- if (!header->next)
- break;
-
- skb_pull(pskb, NETIUCV_HDRLEN);
- header->next -= offset;
- offset += header->next;
- header->next -= NETIUCV_HDRLEN;
- if (skb_tailroom(pskb) < header->next) {
- IUCV_DBF_TEXT_(data, 2, "Illegal next field: %d > %d\n",
- header->next, skb_tailroom(pskb));
- return;
- }
- skb_put(pskb, header->next);
- skb_reset_mac_header(pskb);
- skb = dev_alloc_skb(pskb->len);
- if (!skb) {
- IUCV_DBF_TEXT(data, 2,
- "Out of memory in netiucv_unpack_skb\n");
- privptr->stats.rx_dropped++;
- return;
- }
- skb_copy_from_linear_data(pskb, skb_put(skb, pskb->len),
- pskb->len);
- skb_reset_mac_header(skb);
- skb->dev = pskb->dev;
- skb->protocol = pskb->protocol;
- pskb->ip_summed = CHECKSUM_UNNECESSARY;
- privptr->stats.rx_packets++;
- privptr->stats.rx_bytes += skb->len;
- netif_rx(skb);
- skb_pull(pskb, header->next);
- skb_put(pskb, NETIUCV_HDRLEN);
- }
-}
-
-static void conn_action_rx(fsm_instance *fi, int event, void *arg)
-{
- struct iucv_event *ev = arg;
- struct iucv_connection *conn = ev->conn;
- struct iucv_message *msg = ev->data;
- struct netiucv_priv *privptr = netdev_priv(conn->netdev);
- int rc;
-
- IUCV_DBF_TEXT(trace, 4, __func__);
-
- if (!conn->netdev) {
- iucv_message_reject(conn->path, msg);
- IUCV_DBF_TEXT(data, 2,
- "Received data for unlinked connection\n");
- return;
- }
- if (msg->length > conn->max_buffsize) {
- iucv_message_reject(conn->path, msg);
- privptr->stats.rx_dropped++;
- IUCV_DBF_TEXT_(data, 2, "msglen %d > max_buffsize %d\n",
- msg->length, conn->max_buffsize);
- return;
- }
- conn->rx_buff->data = conn->rx_buff->head;
- skb_reset_tail_pointer(conn->rx_buff);
- conn->rx_buff->len = 0;
- rc = iucv_message_receive(conn->path, msg, 0, conn->rx_buff->data,
- msg->length, NULL);
- if (rc || msg->length < 5) {
- privptr->stats.rx_errors++;
- IUCV_DBF_TEXT_(data, 2, "rc %d from iucv_receive\n", rc);
- return;
- }
- netiucv_unpack_skb(conn, conn->rx_buff);
-}
-
-static void conn_action_txdone(fsm_instance *fi, int event, void *arg)
-{
- struct iucv_event *ev = arg;
- struct iucv_connection *conn = ev->conn;
- struct iucv_message *msg = ev->data;
- struct iucv_message txmsg;
- struct netiucv_priv *privptr = NULL;
- u32 single_flag = msg->tag;
- u32 txbytes = 0;
- u32 txpackets = 0;
- u32 stat_maxcq = 0;
- struct sk_buff *skb;
- unsigned long saveflags;
- struct ll_header header;
- int rc;
-
- IUCV_DBF_TEXT(trace, 4, __func__);
-
- if (!conn || !conn->netdev) {
- IUCV_DBF_TEXT(data, 2,
- "Send confirmation for unlinked connection\n");
- return;
- }
- privptr = netdev_priv(conn->netdev);
- conn->prof.tx_pending--;
- if (single_flag) {
- if ((skb = skb_dequeue(&conn->commit_queue))) {
- refcount_dec(&skb->users);
- if (privptr) {
- privptr->stats.tx_packets++;
- privptr->stats.tx_bytes +=
- (skb->len - NETIUCV_HDRLEN
- - NETIUCV_HDRLEN);
- }
- dev_kfree_skb_any(skb);
- }
- }
- conn->tx_buff->data = conn->tx_buff->head;
- skb_reset_tail_pointer(conn->tx_buff);
- conn->tx_buff->len = 0;
- spin_lock_irqsave(&conn->collect_lock, saveflags);
- while ((skb = skb_dequeue(&conn->collect_queue))) {
- header.next = conn->tx_buff->len + skb->len + NETIUCV_HDRLEN;
- skb_put_data(conn->tx_buff, &header, NETIUCV_HDRLEN);
- skb_copy_from_linear_data(skb,
- skb_put(conn->tx_buff, skb->len),
- skb->len);
- txbytes += skb->len;
- txpackets++;
- stat_maxcq++;
- refcount_dec(&skb->users);
- dev_kfree_skb_any(skb);
- }
- if (conn->collect_len > conn->prof.maxmulti)
- conn->prof.maxmulti = conn->collect_len;
- conn->collect_len = 0;
- spin_unlock_irqrestore(&conn->collect_lock, saveflags);
- if (conn->tx_buff->len == 0) {
- fsm_newstate(fi, CONN_STATE_IDLE);
- return;
- }
-
- header.next = 0;
- skb_put_data(conn->tx_buff, &header, NETIUCV_HDRLEN);
- conn->prof.send_stamp = jiffies;
- txmsg.class = 0;
- txmsg.tag = 0;
- rc = iucv_message_send(conn->path, &txmsg, 0, 0,
- conn->tx_buff->data, conn->tx_buff->len);
- conn->prof.doios_multi++;
- conn->prof.txlen += conn->tx_buff->len;
- conn->prof.tx_pending++;
- if (conn->prof.tx_pending > conn->prof.tx_max_pending)
- conn->prof.tx_max_pending = conn->prof.tx_pending;
- if (rc) {
- conn->prof.tx_pending--;
- fsm_newstate(fi, CONN_STATE_IDLE);
- if (privptr)
- privptr->stats.tx_errors += txpackets;
- IUCV_DBF_TEXT_(data, 2, "rc %d from iucv_send\n", rc);
- } else {
- if (privptr) {
- privptr->stats.tx_packets += txpackets;
- privptr->stats.tx_bytes += txbytes;
- }
- if (stat_maxcq > conn->prof.maxcqueue)
- conn->prof.maxcqueue = stat_maxcq;
- }
-}
-
-static struct iucv_handler netiucv_handler = {
- .path_pending = netiucv_callback_connreq,
- .path_complete = netiucv_callback_connack,
- .path_severed = netiucv_callback_connrej,
- .path_quiesced = netiucv_callback_connsusp,
- .path_resumed = netiucv_callback_connres,
- .message_pending = netiucv_callback_rx,
- .message_complete = netiucv_callback_txdone,
-};
-
-static void conn_action_connaccept(fsm_instance *fi, int event, void *arg)
-{
- struct iucv_event *ev = arg;
- struct iucv_connection *conn = ev->conn;
- struct iucv_path *path = ev->data;
- struct net_device *netdev = conn->netdev;
- struct netiucv_priv *privptr = netdev_priv(netdev);
- int rc;
-
- IUCV_DBF_TEXT(trace, 3, __func__);
-
- conn->path = path;
- path->msglim = NETIUCV_QUEUELEN_DEFAULT;
- path->flags = 0;
- rc = iucv_path_accept(path, &netiucv_handler, conn->userdata , conn);
- if (rc) {
- IUCV_DBF_TEXT_(setup, 2, "rc %d from iucv_accept", rc);
- return;
- }
- fsm_newstate(fi, CONN_STATE_IDLE);
- netdev->tx_queue_len = conn->path->msglim;
- fsm_event(privptr->fsm, DEV_EVENT_CONUP, netdev);
-}
-
-static void conn_action_connreject(fsm_instance *fi, int event, void *arg)
-{
- struct iucv_event *ev = arg;
- struct iucv_path *path = ev->data;
-
- IUCV_DBF_TEXT(trace, 3, __func__);
- iucv_path_sever(path, NULL);
-}
-
-static void conn_action_connack(fsm_instance *fi, int event, void *arg)
-{
- struct iucv_connection *conn = arg;
- struct net_device *netdev = conn->netdev;
- struct netiucv_priv *privptr = netdev_priv(netdev);
-
- IUCV_DBF_TEXT(trace, 3, __func__);
- fsm_deltimer(&conn->timer);
- fsm_newstate(fi, CONN_STATE_IDLE);
- netdev->tx_queue_len = conn->path->msglim;
- fsm_event(privptr->fsm, DEV_EVENT_CONUP, netdev);
-}
-
-static void conn_action_conntimsev(fsm_instance *fi, int event, void *arg)
-{
- struct iucv_connection *conn = arg;
-
- IUCV_DBF_TEXT(trace, 3, __func__);
- fsm_deltimer(&conn->timer);
- iucv_path_sever(conn->path, conn->userdata);
- fsm_newstate(fi, CONN_STATE_STARTWAIT);
-}
-
-static void conn_action_connsever(fsm_instance *fi, int event, void *arg)
-{
- struct iucv_connection *conn = arg;
- struct net_device *netdev = conn->netdev;
- struct netiucv_priv *privptr = netdev_priv(netdev);
-
- IUCV_DBF_TEXT(trace, 3, __func__);
-
- fsm_deltimer(&conn->timer);
- iucv_path_sever(conn->path, conn->userdata);
- dev_info(privptr->dev, "The peer z/VM guest %s has closed the "
- "connection\n", netiucv_printuser(conn));
- IUCV_DBF_TEXT(data, 2,
- "conn_action_connsever: Remote dropped connection\n");
- fsm_newstate(fi, CONN_STATE_STARTWAIT);
- fsm_event(privptr->fsm, DEV_EVENT_CONDOWN, netdev);
-}
-
-static void conn_action_start(fsm_instance *fi, int event, void *arg)
-{
- struct iucv_connection *conn = arg;
- struct net_device *netdev = conn->netdev;
- struct netiucv_priv *privptr = netdev_priv(netdev);
- int rc;
-
- IUCV_DBF_TEXT(trace, 3, __func__);
-
- fsm_newstate(fi, CONN_STATE_STARTWAIT);
-
- /*
- * We must set the state before calling iucv_connect because the
- * callback handler could be called at any point after the connection
- * request is sent
- */
-
- fsm_newstate(fi, CONN_STATE_SETUPWAIT);
- conn->path = iucv_path_alloc(NETIUCV_QUEUELEN_DEFAULT, 0, GFP_KERNEL);
- IUCV_DBF_TEXT_(setup, 2, "%s: connecting to %s ...\n",
- netdev->name, netiucv_printuser(conn));
-
- rc = iucv_path_connect(conn->path, &netiucv_handler, conn->userid,
- NULL, conn->userdata, conn);
- switch (rc) {
- case 0:
- netdev->tx_queue_len = conn->path->msglim;
- fsm_addtimer(&conn->timer, NETIUCV_TIMEOUT_5SEC,
- CONN_EVENT_TIMER, conn);
- return;
- case 11:
- dev_warn(privptr->dev,
- "The IUCV device failed to connect to z/VM guest %s\n",
- netiucv_printname(conn->userid, 8));
- fsm_newstate(fi, CONN_STATE_STARTWAIT);
- break;
- case 12:
- dev_warn(privptr->dev,
- "The IUCV device failed to connect to the peer on z/VM"
- " guest %s\n", netiucv_printname(conn->userid, 8));
- fsm_newstate(fi, CONN_STATE_STARTWAIT);
- break;
- case 13:
- dev_err(privptr->dev,
- "Connecting the IUCV device would exceed the maximum"
- " number of IUCV connections\n");
- fsm_newstate(fi, CONN_STATE_CONNERR);
- break;
- case 14:
- dev_err(privptr->dev,
- "z/VM guest %s has too many IUCV connections"
- " to connect with the IUCV device\n",
- netiucv_printname(conn->userid, 8));
- fsm_newstate(fi, CONN_STATE_CONNERR);
- break;
- case 15:
- dev_err(privptr->dev,
- "The IUCV device cannot connect to a z/VM guest with no"
- " IUCV authorization\n");
- fsm_newstate(fi, CONN_STATE_CONNERR);
- break;
- default:
- dev_err(privptr->dev,
- "Connecting the IUCV device failed with error %d\n",
- rc);
- fsm_newstate(fi, CONN_STATE_CONNERR);
- break;
- }
- IUCV_DBF_TEXT_(setup, 5, "iucv_connect rc is %d\n", rc);
- kfree(conn->path);
- conn->path = NULL;
-}
-
-static void netiucv_purge_skb_queue(struct sk_buff_head *q)
-{
- struct sk_buff *skb;
-
- while ((skb = skb_dequeue(q))) {
- refcount_dec(&skb->users);
- dev_kfree_skb_any(skb);
- }
-}
-
-static void conn_action_stop(fsm_instance *fi, int event, void *arg)
-{
- struct iucv_event *ev = arg;
- struct iucv_connection *conn = ev->conn;
- struct net_device *netdev = conn->netdev;
- struct netiucv_priv *privptr = netdev_priv(netdev);
-
- IUCV_DBF_TEXT(trace, 3, __func__);
-
- fsm_deltimer(&conn->timer);
- fsm_newstate(fi, CONN_STATE_STOPPED);
- netiucv_purge_skb_queue(&conn->collect_queue);
- if (conn->path) {
- IUCV_DBF_TEXT(trace, 5, "calling iucv_path_sever\n");
- iucv_path_sever(conn->path, conn->userdata);
- kfree(conn->path);
- conn->path = NULL;
- }
- netiucv_purge_skb_queue(&conn->commit_queue);
- fsm_event(privptr->fsm, DEV_EVENT_CONDOWN, netdev);
-}
-
-static void conn_action_inval(fsm_instance *fi, int event, void *arg)
-{
- struct iucv_connection *conn = arg;
- struct net_device *netdev = conn->netdev;
-
- IUCV_DBF_TEXT_(data, 2, "%s('%s'): conn_action_inval called\n",
- netdev->name, conn->userid);
-}
-
-static const fsm_node conn_fsm[] = {
- { CONN_STATE_INVALID, CONN_EVENT_START, conn_action_inval },
- { CONN_STATE_STOPPED, CONN_EVENT_START, conn_action_start },
-
- { CONN_STATE_STOPPED, CONN_EVENT_STOP, conn_action_stop },
- { CONN_STATE_STARTWAIT, CONN_EVENT_STOP, conn_action_stop },
- { CONN_STATE_SETUPWAIT, CONN_EVENT_STOP, conn_action_stop },
- { CONN_STATE_IDLE, CONN_EVENT_STOP, conn_action_stop },
- { CONN_STATE_TX, CONN_EVENT_STOP, conn_action_stop },
- { CONN_STATE_REGERR, CONN_EVENT_STOP, conn_action_stop },
- { CONN_STATE_CONNERR, CONN_EVENT_STOP, conn_action_stop },
-
- { CONN_STATE_STOPPED, CONN_EVENT_CONN_REQ, conn_action_connreject },
- { CONN_STATE_STARTWAIT, CONN_EVENT_CONN_REQ, conn_action_connaccept },
- { CONN_STATE_SETUPWAIT, CONN_EVENT_CONN_REQ, conn_action_connaccept },
- { CONN_STATE_IDLE, CONN_EVENT_CONN_REQ, conn_action_connreject },
- { CONN_STATE_TX, CONN_EVENT_CONN_REQ, conn_action_connreject },
-
- { CONN_STATE_SETUPWAIT, CONN_EVENT_CONN_ACK, conn_action_connack },
- { CONN_STATE_SETUPWAIT, CONN_EVENT_TIMER, conn_action_conntimsev },
-
- { CONN_STATE_SETUPWAIT, CONN_EVENT_CONN_REJ, conn_action_connsever },
- { CONN_STATE_IDLE, CONN_EVENT_CONN_REJ, conn_action_connsever },
- { CONN_STATE_TX, CONN_EVENT_CONN_REJ, conn_action_connsever },
-
- { CONN_STATE_IDLE, CONN_EVENT_RX, conn_action_rx },
- { CONN_STATE_TX, CONN_EVENT_RX, conn_action_rx },
-
- { CONN_STATE_TX, CONN_EVENT_TXDONE, conn_action_txdone },
- { CONN_STATE_IDLE, CONN_EVENT_TXDONE, conn_action_txdone },
-};
-
-static const int CONN_FSM_LEN = sizeof(conn_fsm) / sizeof(fsm_node);
-
-
-/*
- * Actions for interface - statemachine.
- */
-
-/*
- * dev_action_start
- * @fi: An instance of an interface statemachine.
- * @event: The event, just happened.
- * @arg: Generic pointer, casted from struct net_device * upon call.
- *
- * Startup connection by sending CONN_EVENT_START to it.
- */
-static void dev_action_start(fsm_instance *fi, int event, void *arg)
-{
- struct net_device *dev = arg;
- struct netiucv_priv *privptr = netdev_priv(dev);
-
- IUCV_DBF_TEXT(trace, 3, __func__);
-
- fsm_newstate(fi, DEV_STATE_STARTWAIT);
- fsm_event(privptr->conn->fsm, CONN_EVENT_START, privptr->conn);
-}
-
-/*
- * Shutdown connection by sending CONN_EVENT_STOP to it.
- *
- * @param fi An instance of an interface statemachine.
- * @param event The event, just happened.
- * @param arg Generic pointer, casted from struct net_device * upon call.
- */
-static void
-dev_action_stop(fsm_instance *fi, int event, void *arg)
-{
- struct net_device *dev = arg;
- struct netiucv_priv *privptr = netdev_priv(dev);
- struct iucv_event ev;
-
- IUCV_DBF_TEXT(trace, 3, __func__);
-
- ev.conn = privptr->conn;
-
- fsm_newstate(fi, DEV_STATE_STOPWAIT);
- fsm_event(privptr->conn->fsm, CONN_EVENT_STOP, &ev);
-}
-
-/*
- * Called from connection statemachine
- * when a connection is up and running.
- *
- * @param fi An instance of an interface statemachine.
- * @param event The event, just happened.
- * @param arg Generic pointer, casted from struct net_device * upon call.
- */
-static void
-dev_action_connup(fsm_instance *fi, int event, void *arg)
-{
- struct net_device *dev = arg;
- struct netiucv_priv *privptr = netdev_priv(dev);
-
- IUCV_DBF_TEXT(trace, 3, __func__);
-
- switch (fsm_getstate(fi)) {
- case DEV_STATE_STARTWAIT:
- fsm_newstate(fi, DEV_STATE_RUNNING);
- dev_info(privptr->dev,
- "The IUCV device has been connected"
- " successfully to %s\n",
- netiucv_printuser(privptr->conn));
- IUCV_DBF_TEXT(setup, 3,
- "connection is up and running\n");
- break;
- case DEV_STATE_STOPWAIT:
- IUCV_DBF_TEXT(data, 2,
- "dev_action_connup: in DEV_STATE_STOPWAIT\n");
- break;
- }
-}
-
-/*
- * Called from connection statemachine
- * when a connection has been shutdown.
- *
- * @param fi An instance of an interface statemachine.
- * @param event The event, just happened.
- * @param arg Generic pointer, casted from struct net_device * upon call.
- */
-static void
-dev_action_conndown(fsm_instance *fi, int event, void *arg)
-{
- IUCV_DBF_TEXT(trace, 3, __func__);
-
- switch (fsm_getstate(fi)) {
- case DEV_STATE_RUNNING:
- fsm_newstate(fi, DEV_STATE_STARTWAIT);
- break;
- case DEV_STATE_STOPWAIT:
- fsm_newstate(fi, DEV_STATE_STOPPED);
- IUCV_DBF_TEXT(setup, 3, "connection is down\n");
- break;
- }
-}
-
-static const fsm_node dev_fsm[] = {
- { DEV_STATE_STOPPED, DEV_EVENT_START, dev_action_start },
-
- { DEV_STATE_STOPWAIT, DEV_EVENT_START, dev_action_start },
- { DEV_STATE_STOPWAIT, DEV_EVENT_CONDOWN, dev_action_conndown },
-
- { DEV_STATE_STARTWAIT, DEV_EVENT_STOP, dev_action_stop },
- { DEV_STATE_STARTWAIT, DEV_EVENT_CONUP, dev_action_connup },
-
- { DEV_STATE_RUNNING, DEV_EVENT_STOP, dev_action_stop },
- { DEV_STATE_RUNNING, DEV_EVENT_CONDOWN, dev_action_conndown },
- { DEV_STATE_RUNNING, DEV_EVENT_CONUP, netiucv_action_nop },
-};
-
-static const int DEV_FSM_LEN = sizeof(dev_fsm) / sizeof(fsm_node);
-
-/*
- * Transmit a packet.
- * This is a helper function for netiucv_tx().
- *
- * @param conn Connection to be used for sending.
- * @param skb Pointer to struct sk_buff of packet to send.
- * The linklevel header has already been set up
- * by netiucv_tx().
- *
- * @return 0 on success, -ERRNO on failure. (Never fails.)
- */
-static int netiucv_transmit_skb(struct iucv_connection *conn,
- struct sk_buff *skb)
-{
- struct iucv_message msg;
- unsigned long saveflags;
- struct ll_header header;
- int rc;
-
- if (fsm_getstate(conn->fsm) != CONN_STATE_IDLE) {
- int l = skb->len + NETIUCV_HDRLEN;
-
- spin_lock_irqsave(&conn->collect_lock, saveflags);
- if (conn->collect_len + l >
- (conn->max_buffsize - NETIUCV_HDRLEN)) {
- rc = -EBUSY;
- IUCV_DBF_TEXT(data, 2,
- "EBUSY from netiucv_transmit_skb\n");
- } else {
- refcount_inc(&skb->users);
- skb_queue_tail(&conn->collect_queue, skb);
- conn->collect_len += l;
- rc = 0;
- }
- spin_unlock_irqrestore(&conn->collect_lock, saveflags);
- } else {
- struct sk_buff *nskb = skb;
- /*
- * Copy the skb to a new allocated skb in lowmem only if the
- * data is located above 2G in memory or tailroom is < 2.
- */
- unsigned long hi = ((unsigned long)(skb_tail_pointer(skb) +
- NETIUCV_HDRLEN)) >> 31;
- int copied = 0;
- if (hi || (skb_tailroom(skb) < 2)) {
- nskb = alloc_skb(skb->len + NETIUCV_HDRLEN +
- NETIUCV_HDRLEN, GFP_ATOMIC | GFP_DMA);
- if (!nskb) {
- IUCV_DBF_TEXT(data, 2, "alloc_skb failed\n");
- rc = -ENOMEM;
- return rc;
- } else {
- skb_reserve(nskb, NETIUCV_HDRLEN);
- skb_put_data(nskb, skb->data, skb->len);
- }
- copied = 1;
- }
- /*
- * skb now is below 2G and has enough room. Add headers.
- */
- header.next = nskb->len + NETIUCV_HDRLEN;
- memcpy(skb_push(nskb, NETIUCV_HDRLEN), &header, NETIUCV_HDRLEN);
- header.next = 0;
- skb_put_data(nskb, &header, NETIUCV_HDRLEN);
-
- fsm_newstate(conn->fsm, CONN_STATE_TX);
- conn->prof.send_stamp = jiffies;
-
- msg.tag = 1;
- msg.class = 0;
- rc = iucv_message_send(conn->path, &msg, 0, 0,
- nskb->data, nskb->len);
- conn->prof.doios_single++;
- conn->prof.txlen += skb->len;
- conn->prof.tx_pending++;
- if (conn->prof.tx_pending > conn->prof.tx_max_pending)
- conn->prof.tx_max_pending = conn->prof.tx_pending;
- if (rc) {
- struct netiucv_priv *privptr;
- fsm_newstate(conn->fsm, CONN_STATE_IDLE);
- conn->prof.tx_pending--;
- privptr = netdev_priv(conn->netdev);
- if (privptr)
- privptr->stats.tx_errors++;
- if (copied)
- dev_kfree_skb(nskb);
- else {
- /*
- * Remove our headers. They get added
- * again on retransmit.
- */
- skb_pull(skb, NETIUCV_HDRLEN);
- skb_trim(skb, skb->len - NETIUCV_HDRLEN);
- }
- IUCV_DBF_TEXT_(data, 2, "rc %d from iucv_send\n", rc);
- } else {
- if (copied)
- dev_kfree_skb(skb);
- refcount_inc(&nskb->users);
- skb_queue_tail(&conn->commit_queue, nskb);
- }
- }
-
- return rc;
-}
-
-/*
- * Interface API for upper network layers
- */
-
-/*
- * Open an interface.
- * Called from generic network layer when ifconfig up is run.
- *
- * @param dev Pointer to interface struct.
- *
- * @return 0 on success, -ERRNO on failure. (Never fails.)
- */
-static int netiucv_open(struct net_device *dev)
-{
- struct netiucv_priv *priv = netdev_priv(dev);
-
- fsm_event(priv->fsm, DEV_EVENT_START, dev);
- return 0;
-}
-
-/*
- * Close an interface.
- * Called from generic network layer when ifconfig down is run.
- *
- * @param dev Pointer to interface struct.
- *
- * @return 0 on success, -ERRNO on failure. (Never fails.)
- */
-static int netiucv_close(struct net_device *dev)
-{
- struct netiucv_priv *priv = netdev_priv(dev);
-
- fsm_event(priv->fsm, DEV_EVENT_STOP, dev);
- return 0;
-}
-
-/*
- * Start transmission of a packet.
- * Called from generic network device layer.
- */
-static netdev_tx_t netiucv_tx(struct sk_buff *skb, struct net_device *dev)
-{
- struct netiucv_priv *privptr = netdev_priv(dev);
- int rc;
-
- IUCV_DBF_TEXT(trace, 4, __func__);
- /*
- * Some sanity checks ...
- */
- if (skb == NULL) {
- IUCV_DBF_TEXT(data, 2, "netiucv_tx: skb is NULL\n");
- privptr->stats.tx_dropped++;
- return NETDEV_TX_OK;
- }
- if (skb_headroom(skb) < NETIUCV_HDRLEN) {
- IUCV_DBF_TEXT(data, 2,
- "netiucv_tx: skb_headroom < NETIUCV_HDRLEN\n");
- dev_kfree_skb(skb);
- privptr->stats.tx_dropped++;
- return NETDEV_TX_OK;
- }
-
- /*
- * If connection is not running, try to restart it
- * and throw away packet.
- */
- if (fsm_getstate(privptr->fsm) != DEV_STATE_RUNNING) {
- dev_kfree_skb(skb);
- privptr->stats.tx_dropped++;
- privptr->stats.tx_errors++;
- privptr->stats.tx_carrier_errors++;
- return NETDEV_TX_OK;
- }
-
- if (netiucv_test_and_set_busy(dev)) {
- IUCV_DBF_TEXT(data, 2, "EBUSY from netiucv_tx\n");
- return NETDEV_TX_BUSY;
- }
- netif_trans_update(dev);
- rc = netiucv_transmit_skb(privptr->conn, skb);
- netiucv_clear_busy(dev);
- return rc ? NETDEV_TX_BUSY : NETDEV_TX_OK;
-}
-
-/*
- * netiucv_stats
- * @dev: Pointer to interface struct.
- *
- * Returns interface statistics of a device.
- *
- * Returns pointer to stats struct of this interface.
- */
-static struct net_device_stats *netiucv_stats (struct net_device * dev)
-{
- struct netiucv_priv *priv = netdev_priv(dev);
-
- IUCV_DBF_TEXT(trace, 5, __func__);
- return &priv->stats;
-}
-
-/*
- * attributes in sysfs
- */
-
-static ssize_t user_show(struct device *dev, struct device_attribute *attr,
- char *buf)
-{
- struct netiucv_priv *priv = dev_get_drvdata(dev);
-
- IUCV_DBF_TEXT(trace, 5, __func__);
- return sysfs_emit(buf, "%s\n", netiucv_printuser(priv->conn));
-}
-
-static int netiucv_check_user(const char *buf, size_t count, char *username,
- char *userdata)
-{
- const char *p;
- int i;
-
- p = strchr(buf, '.');
- if ((p && ((count > 26) ||
- ((p - buf) > 8) ||
- (buf + count - p > 18))) ||
- (!p && (count > 9))) {
- IUCV_DBF_TEXT(setup, 2, "conn_write: too long\n");
- return -EINVAL;
- }
-
- for (i = 0, p = buf; i < 8 && *p && *p != '.'; i++, p++) {
- if (isalnum(*p) || *p == '$') {
- username[i] = toupper(*p);
- continue;
- }
- if (*p == '\n')
- /* trailing lf, grr */
- break;
- IUCV_DBF_TEXT_(setup, 2,
- "conn_write: invalid character %02x\n", *p);
- return -EINVAL;
- }
- while (i < 8)
- username[i++] = ' ';
- username[8] = '\0';
-
- if (*p == '.') {
- p++;
- for (i = 0; i < 16 && *p; i++, p++) {
- if (*p == '\n')
- break;
- userdata[i] = toupper(*p);
- }
- while (i > 0 && i < 16)
- userdata[i++] = ' ';
- } else
- memcpy(userdata, iucvMagic_ascii, 16);
- userdata[16] = '\0';
- ASCEBC(userdata, 16);
-
- return 0;
-}
-
-static ssize_t user_write(struct device *dev, struct device_attribute *attr,
- const char *buf, size_t count)
-{
- struct netiucv_priv *priv = dev_get_drvdata(dev);
- struct net_device *ndev = priv->conn->netdev;
- char username[9];
- char userdata[17];
- int rc;
- struct iucv_connection *cp;
-
- IUCV_DBF_TEXT(trace, 3, __func__);
- rc = netiucv_check_user(buf, count, username, userdata);
- if (rc)
- return rc;
-
- if (memcmp(username, priv->conn->userid, 9) &&
- (ndev->flags & (IFF_UP | IFF_RUNNING))) {
- /* username changed while the interface is active. */
- IUCV_DBF_TEXT(setup, 2, "user_write: device active\n");
- return -EPERM;
- }
- read_lock_bh(&iucv_connection_rwlock);
- list_for_each_entry(cp, &iucv_connection_list, list) {
- if (!strncmp(username, cp->userid, 9) &&
- !strncmp(userdata, cp->userdata, 17) && cp->netdev != ndev) {
- read_unlock_bh(&iucv_connection_rwlock);
- IUCV_DBF_TEXT_(setup, 2, "user_write: Connection to %s "
- "already exists\n", netiucv_printuser(cp));
- return -EEXIST;
- }
- }
- read_unlock_bh(&iucv_connection_rwlock);
- memcpy(priv->conn->userid, username, 9);
- memcpy(priv->conn->userdata, userdata, 17);
- return count;
-}
-
-static DEVICE_ATTR(user, 0644, user_show, user_write);
-
-static ssize_t buffer_show (struct device *dev, struct device_attribute *attr,
- char *buf)
-{
- struct netiucv_priv *priv = dev_get_drvdata(dev);
-
- IUCV_DBF_TEXT(trace, 5, __func__);
- return sysfs_emit(buf, "%d\n", priv->conn->max_buffsize);
-}
-
-static ssize_t buffer_write (struct device *dev, struct device_attribute *attr,
- const char *buf, size_t count)
-{
- struct netiucv_priv *priv = dev_get_drvdata(dev);
- struct net_device *ndev = priv->conn->netdev;
- unsigned int bs1;
- int rc;
-
- IUCV_DBF_TEXT(trace, 3, __func__);
- if (count >= 39)
- return -EINVAL;
-
- rc = kstrtouint(buf, 0, &bs1);
-
- if (rc == -EINVAL) {
- IUCV_DBF_TEXT_(setup, 2, "buffer_write: invalid char %s\n",
- buf);
- return -EINVAL;
- }
- if ((rc == -ERANGE) || (bs1 > NETIUCV_BUFSIZE_MAX)) {
- IUCV_DBF_TEXT_(setup, 2,
- "buffer_write: buffer size %d too large\n",
- bs1);
- return -EINVAL;
- }
- if ((ndev->flags & IFF_RUNNING) &&
- (bs1 < (ndev->mtu + NETIUCV_HDRLEN + 2))) {
- IUCV_DBF_TEXT_(setup, 2,
- "buffer_write: buffer size %d too small\n",
- bs1);
- return -EINVAL;
- }
- if (bs1 < (576 + NETIUCV_HDRLEN + NETIUCV_HDRLEN)) {
- IUCV_DBF_TEXT_(setup, 2,
- "buffer_write: buffer size %d too small\n",
- bs1);
- return -EINVAL;
- }
-
- priv->conn->max_buffsize = bs1;
- if (!(ndev->flags & IFF_RUNNING))
- ndev->mtu = bs1 - NETIUCV_HDRLEN - NETIUCV_HDRLEN;
-
- return count;
-
-}
-
-static DEVICE_ATTR(buffer, 0644, buffer_show, buffer_write);
-
-static ssize_t dev_fsm_show (struct device *dev, struct device_attribute *attr,
- char *buf)
-{
- struct netiucv_priv *priv = dev_get_drvdata(dev);
-
- IUCV_DBF_TEXT(trace, 5, __func__);
- return sysfs_emit(buf, "%s\n", fsm_getstate_str(priv->fsm));
-}
-
-static DEVICE_ATTR(device_fsm_state, 0444, dev_fsm_show, NULL);
-
-static ssize_t conn_fsm_show (struct device *dev,
- struct device_attribute *attr, char *buf)
-{
- struct netiucv_priv *priv = dev_get_drvdata(dev);
-
- IUCV_DBF_TEXT(trace, 5, __func__);
- return sysfs_emit(buf, "%s\n", fsm_getstate_str(priv->conn->fsm));
-}
-
-static DEVICE_ATTR(connection_fsm_state, 0444, conn_fsm_show, NULL);
-
-static ssize_t maxmulti_show (struct device *dev,
- struct device_attribute *attr, char *buf)
-{
- struct netiucv_priv *priv = dev_get_drvdata(dev);
-
- IUCV_DBF_TEXT(trace, 5, __func__);
- return sysfs_emit(buf, "%ld\n", priv->conn->prof.maxmulti);
-}
-
-static ssize_t maxmulti_write (struct device *dev,
- struct device_attribute *attr,
- const char *buf, size_t count)
-{
- struct netiucv_priv *priv = dev_get_drvdata(dev);
-
- IUCV_DBF_TEXT(trace, 4, __func__);
- priv->conn->prof.maxmulti = 0;
- return count;
-}
-
-static DEVICE_ATTR(max_tx_buffer_used, 0644, maxmulti_show, maxmulti_write);
-
-static ssize_t maxcq_show (struct device *dev, struct device_attribute *attr,
- char *buf)
-{
- struct netiucv_priv *priv = dev_get_drvdata(dev);
-
- IUCV_DBF_TEXT(trace, 5, __func__);
- return sysfs_emit(buf, "%ld\n", priv->conn->prof.maxcqueue);
-}
-
-static ssize_t maxcq_write (struct device *dev, struct device_attribute *attr,
- const char *buf, size_t count)
-{
- struct netiucv_priv *priv = dev_get_drvdata(dev);
-
- IUCV_DBF_TEXT(trace, 4, __func__);
- priv->conn->prof.maxcqueue = 0;
- return count;
-}
-
-static DEVICE_ATTR(max_chained_skbs, 0644, maxcq_show, maxcq_write);
-
-static ssize_t sdoio_show (struct device *dev, struct device_attribute *attr,
- char *buf)
-{
- struct netiucv_priv *priv = dev_get_drvdata(dev);
-
- IUCV_DBF_TEXT(trace, 5, __func__);
- return sysfs_emit(buf, "%ld\n", priv->conn->prof.doios_single);
-}
-
-static ssize_t sdoio_write (struct device *dev, struct device_attribute *attr,
- const char *buf, size_t count)
-{
- struct netiucv_priv *priv = dev_get_drvdata(dev);
-
- IUCV_DBF_TEXT(trace, 4, __func__);
- priv->conn->prof.doios_single = 0;
- return count;
-}
-
-static DEVICE_ATTR(tx_single_write_ops, 0644, sdoio_show, sdoio_write);
-
-static ssize_t mdoio_show (struct device *dev, struct device_attribute *attr,
- char *buf)
-{
- struct netiucv_priv *priv = dev_get_drvdata(dev);
-
- IUCV_DBF_TEXT(trace, 5, __func__);
- return sysfs_emit(buf, "%ld\n", priv->conn->prof.doios_multi);
-}
-
-static ssize_t mdoio_write (struct device *dev, struct device_attribute *attr,
- const char *buf, size_t count)
-{
- struct netiucv_priv *priv = dev_get_drvdata(dev);
-
- IUCV_DBF_TEXT(trace, 5, __func__);
- priv->conn->prof.doios_multi = 0;
- return count;
-}
-
-static DEVICE_ATTR(tx_multi_write_ops, 0644, mdoio_show, mdoio_write);
-
-static ssize_t txlen_show (struct device *dev, struct device_attribute *attr,
- char *buf)
-{
- struct netiucv_priv *priv = dev_get_drvdata(dev);
-
- IUCV_DBF_TEXT(trace, 5, __func__);
- return sysfs_emit(buf, "%ld\n", priv->conn->prof.txlen);
-}
-
-static ssize_t txlen_write (struct device *dev, struct device_attribute *attr,
- const char *buf, size_t count)
-{
- struct netiucv_priv *priv = dev_get_drvdata(dev);
-
- IUCV_DBF_TEXT(trace, 4, __func__);
- priv->conn->prof.txlen = 0;
- return count;
-}
-
-static DEVICE_ATTR(netto_bytes, 0644, txlen_show, txlen_write);
-
-static ssize_t txtime_show (struct device *dev, struct device_attribute *attr,
- char *buf)
-{
- struct netiucv_priv *priv = dev_get_drvdata(dev);
-
- IUCV_DBF_TEXT(trace, 5, __func__);
- return sysfs_emit(buf, "%ld\n", priv->conn->prof.tx_time);
-}
-
-static ssize_t txtime_write (struct device *dev, struct device_attribute *attr,
- const char *buf, size_t count)
-{
- struct netiucv_priv *priv = dev_get_drvdata(dev);
-
- IUCV_DBF_TEXT(trace, 4, __func__);
- priv->conn->prof.tx_time = 0;
- return count;
-}
-
-static DEVICE_ATTR(max_tx_io_time, 0644, txtime_show, txtime_write);
-
-static ssize_t txpend_show (struct device *dev, struct device_attribute *attr,
- char *buf)
-{
- struct netiucv_priv *priv = dev_get_drvdata(dev);
-
- IUCV_DBF_TEXT(trace, 5, __func__);
- return sysfs_emit(buf, "%ld\n", priv->conn->prof.tx_pending);
-}
-
-static ssize_t txpend_write (struct device *dev, struct device_attribute *attr,
- const char *buf, size_t count)
-{
- struct netiucv_priv *priv = dev_get_drvdata(dev);
-
- IUCV_DBF_TEXT(trace, 4, __func__);
- priv->conn->prof.tx_pending = 0;
- return count;
-}
-
-static DEVICE_ATTR(tx_pending, 0644, txpend_show, txpend_write);
-
-static ssize_t txmpnd_show (struct device *dev, struct device_attribute *attr,
- char *buf)
-{
- struct netiucv_priv *priv = dev_get_drvdata(dev);
-
- IUCV_DBF_TEXT(trace, 5, __func__);
- return sysfs_emit(buf, "%ld\n", priv->conn->prof.tx_max_pending);
-}
-
-static ssize_t txmpnd_write (struct device *dev, struct device_attribute *attr,
- const char *buf, size_t count)
-{
- struct netiucv_priv *priv = dev_get_drvdata(dev);
-
- IUCV_DBF_TEXT(trace, 4, __func__);
- priv->conn->prof.tx_max_pending = 0;
- return count;
-}
-
-static DEVICE_ATTR(tx_max_pending, 0644, txmpnd_show, txmpnd_write);
-
-static struct attribute *netiucv_attrs[] = {
- &dev_attr_buffer.attr,
- &dev_attr_user.attr,
- NULL,
-};
-
-static struct attribute_group netiucv_attr_group = {
- .attrs = netiucv_attrs,
-};
-
-static struct attribute *netiucv_stat_attrs[] = {
- &dev_attr_device_fsm_state.attr,
- &dev_attr_connection_fsm_state.attr,
- &dev_attr_max_tx_buffer_used.attr,
- &dev_attr_max_chained_skbs.attr,
- &dev_attr_tx_single_write_ops.attr,
- &dev_attr_tx_multi_write_ops.attr,
- &dev_attr_netto_bytes.attr,
- &dev_attr_max_tx_io_time.attr,
- &dev_attr_tx_pending.attr,
- &dev_attr_tx_max_pending.attr,
- NULL,
-};
-
-static struct attribute_group netiucv_stat_attr_group = {
- .name = "stats",
- .attrs = netiucv_stat_attrs,
-};
-
-static const struct attribute_group *netiucv_attr_groups[] = {
- &netiucv_stat_attr_group,
- &netiucv_attr_group,
- NULL,
-};
-
-static int netiucv_register_device(struct net_device *ndev)
-{
- struct netiucv_priv *priv = netdev_priv(ndev);
- struct device *dev;
- int ret;
-
- IUCV_DBF_TEXT(trace, 3, __func__);
-
- dev = iucv_alloc_device(netiucv_attr_groups, &netiucv_driver, NULL,
- "net%s", ndev->name);
- if (!dev)
- return -ENOMEM;
-
- ret = device_register(dev);
- if (ret) {
- put_device(dev);
- return ret;
- }
- priv->dev = dev;
- dev_set_drvdata(dev, priv);
- return 0;
-}
-
-static void netiucv_unregister_device(struct device *dev)
-{
- IUCV_DBF_TEXT(trace, 3, __func__);
- device_unregister(dev);
-}
-
-/*
- * Allocate and initialize a new connection structure.
- * Add it to the list of netiucv connections;
- */
-static struct iucv_connection *netiucv_new_connection(struct net_device *dev,
- char *username,
- char *userdata)
-{
- struct iucv_connection *conn;
-
- conn = kzalloc(sizeof(*conn), GFP_KERNEL);
- if (!conn)
- goto out;
- skb_queue_head_init(&conn->collect_queue);
- skb_queue_head_init(&conn->commit_queue);
- spin_lock_init(&conn->collect_lock);
- conn->max_buffsize = NETIUCV_BUFSIZE_DEFAULT;
- conn->netdev = dev;
-
- conn->rx_buff = alloc_skb(conn->max_buffsize, GFP_KERNEL | GFP_DMA);
- if (!conn->rx_buff)
- goto out_conn;
- conn->tx_buff = alloc_skb(conn->max_buffsize, GFP_KERNEL | GFP_DMA);
- if (!conn->tx_buff)
- goto out_rx;
- conn->fsm = init_fsm("netiucvconn", conn_state_names,
- conn_event_names, NR_CONN_STATES,
- NR_CONN_EVENTS, conn_fsm, CONN_FSM_LEN,
- GFP_KERNEL);
- if (!conn->fsm)
- goto out_tx;
-
- fsm_settimer(conn->fsm, &conn->timer);
- fsm_newstate(conn->fsm, CONN_STATE_INVALID);
-
- if (userdata)
- memcpy(conn->userdata, userdata, 17);
- if (username) {
- memcpy(conn->userid, username, 9);
- fsm_newstate(conn->fsm, CONN_STATE_STOPPED);
- }
-
- write_lock_bh(&iucv_connection_rwlock);
- list_add_tail(&conn->list, &iucv_connection_list);
- write_unlock_bh(&iucv_connection_rwlock);
- return conn;
-
-out_tx:
- kfree_skb(conn->tx_buff);
-out_rx:
- kfree_skb(conn->rx_buff);
-out_conn:
- kfree(conn);
-out:
- return NULL;
-}
-
-/*
- * Release a connection structure and remove it from the
- * list of netiucv connections.
- */
-static void netiucv_remove_connection(struct iucv_connection *conn)
-{
-
- IUCV_DBF_TEXT(trace, 3, __func__);
- write_lock_bh(&iucv_connection_rwlock);
- list_del_init(&conn->list);
- write_unlock_bh(&iucv_connection_rwlock);
- fsm_deltimer(&conn->timer);
- netiucv_purge_skb_queue(&conn->collect_queue);
- if (conn->path) {
- iucv_path_sever(conn->path, conn->userdata);
- kfree(conn->path);
- conn->path = NULL;
- }
- netiucv_purge_skb_queue(&conn->commit_queue);
- kfree_fsm(conn->fsm);
- kfree_skb(conn->rx_buff);
- kfree_skb(conn->tx_buff);
-}
-
-/*
- * Release everything of a net device.
- */
-static void netiucv_free_netdevice(struct net_device *dev)
-{
- struct netiucv_priv *privptr = netdev_priv(dev);
-
- IUCV_DBF_TEXT(trace, 3, __func__);
-
- if (!dev)
- return;
-
- if (privptr) {
- if (privptr->conn)
- netiucv_remove_connection(privptr->conn);
- if (privptr->fsm)
- kfree_fsm(privptr->fsm);
- privptr->conn = NULL; privptr->fsm = NULL;
- /* privptr gets freed by free_netdev() */
- }
-}
-
-/*
- * Initialize a net device. (Called from kernel in alloc_netdev())
- */
-static const struct net_device_ops netiucv_netdev_ops = {
- .ndo_open = netiucv_open,
- .ndo_stop = netiucv_close,
- .ndo_get_stats = netiucv_stats,
- .ndo_start_xmit = netiucv_tx,
-};
-
-static void netiucv_setup_netdevice(struct net_device *dev)
-{
- dev->mtu = NETIUCV_MTU_DEFAULT;
- dev->min_mtu = 576;
- dev->max_mtu = NETIUCV_MTU_MAX;
- dev->needs_free_netdev = true;
- dev->priv_destructor = netiucv_free_netdevice;
- dev->hard_header_len = NETIUCV_HDRLEN;
- dev->addr_len = 0;
- dev->type = ARPHRD_SLIP;
- dev->tx_queue_len = NETIUCV_QUEUELEN_DEFAULT;
- dev->flags = IFF_POINTOPOINT | IFF_NOARP;
- dev->netdev_ops = &netiucv_netdev_ops;
-}
-
-/*
- * Allocate and initialize everything of a net device.
- */
-static struct net_device *netiucv_init_netdevice(char *username, char *userdata)
-{
- struct netiucv_priv *privptr;
- struct net_device *dev;
-
- dev = alloc_netdev(sizeof(struct netiucv_priv), "iucv%d",
- NET_NAME_UNKNOWN, netiucv_setup_netdevice);
- if (!dev)
- return NULL;
- rtnl_lock();
- if (dev_alloc_name(dev, dev->name) < 0)
- goto out_netdev;
-
- privptr = netdev_priv(dev);
- privptr->fsm = init_fsm("netiucvdev", dev_state_names,
- dev_event_names, NR_DEV_STATES, NR_DEV_EVENTS,
- dev_fsm, DEV_FSM_LEN, GFP_KERNEL);
- if (!privptr->fsm)
- goto out_netdev;
-
- privptr->conn = netiucv_new_connection(dev, username, userdata);
- if (!privptr->conn) {
- IUCV_DBF_TEXT(setup, 2, "NULL from netiucv_new_connection\n");
- goto out_fsm;
- }
- fsm_newstate(privptr->fsm, DEV_STATE_STOPPED);
- return dev;
-
-out_fsm:
- kfree_fsm(privptr->fsm);
-out_netdev:
- rtnl_unlock();
- free_netdev(dev);
- return NULL;
-}
-
-static ssize_t connection_store(struct device_driver *drv, const char *buf,
- size_t count)
-{
- char username[9];
- char userdata[17];
- int rc;
- struct net_device *dev;
- struct netiucv_priv *priv;
- struct iucv_connection *cp;
-
- IUCV_DBF_TEXT(trace, 3, __func__);
- rc = netiucv_check_user(buf, count, username, userdata);
- if (rc)
- return rc;
-
- read_lock_bh(&iucv_connection_rwlock);
- list_for_each_entry(cp, &iucv_connection_list, list) {
- if (!strncmp(username, cp->userid, 9) &&
- !strncmp(userdata, cp->userdata, 17)) {
- read_unlock_bh(&iucv_connection_rwlock);
- IUCV_DBF_TEXT_(setup, 2, "conn_write: Connection to %s "
- "already exists\n", netiucv_printuser(cp));
- return -EEXIST;
- }
- }
- read_unlock_bh(&iucv_connection_rwlock);
-
- dev = netiucv_init_netdevice(username, userdata);
- if (!dev) {
- IUCV_DBF_TEXT(setup, 2, "NULL from netiucv_init_netdevice\n");
- return -ENODEV;
- }
-
- rc = netiucv_register_device(dev);
- if (rc) {
- rtnl_unlock();
- IUCV_DBF_TEXT_(setup, 2,
- "ret %d from netiucv_register_device\n", rc);
- goto out_free_ndev;
- }
-
- /* sysfs magic */
- priv = netdev_priv(dev);
- SET_NETDEV_DEV(dev, priv->dev);
-
- rc = register_netdevice(dev);
- rtnl_unlock();
- if (rc)
- goto out_unreg;
-
- dev_info(priv->dev, "The IUCV interface to %s has been established "
- "successfully\n",
- netiucv_printuser(priv->conn));
-
- return count;
-
-out_unreg:
- netiucv_unregister_device(priv->dev);
-out_free_ndev:
- netiucv_free_netdevice(dev);
- return rc;
-}
-static DRIVER_ATTR_WO(connection);
-
-static ssize_t remove_store(struct device_driver *drv, const char *buf,
- size_t count)
-{
- struct iucv_connection *cp;
- struct net_device *ndev;
- struct netiucv_priv *priv;
- struct device *dev;
- char name[IFNAMSIZ];
- const char *p;
- int i;
-
- IUCV_DBF_TEXT(trace, 3, __func__);
-
- if (count >= IFNAMSIZ)
- count = IFNAMSIZ - 1;
-
- for (i = 0, p = buf; i < count && *p; i++, p++) {
- if (*p == '\n' || *p == ' ')
- /* trailing lf, grr */
- break;
- name[i] = *p;
- }
- name[i] = '\0';
-
- read_lock_bh(&iucv_connection_rwlock);
- list_for_each_entry(cp, &iucv_connection_list, list) {
- ndev = cp->netdev;
- priv = netdev_priv(ndev);
- dev = priv->dev;
- if (strncmp(name, ndev->name, count))
- continue;
- read_unlock_bh(&iucv_connection_rwlock);
- if (ndev->flags & (IFF_UP | IFF_RUNNING)) {
- dev_warn(dev, "The IUCV device is connected"
- " to %s and cannot be removed\n",
- priv->conn->userid);
- IUCV_DBF_TEXT(data, 2, "remove_write: still active\n");
- return -EPERM;
- }
- unregister_netdev(ndev);
- netiucv_unregister_device(dev);
- return count;
- }
- read_unlock_bh(&iucv_connection_rwlock);
- IUCV_DBF_TEXT(data, 2, "remove_write: unknown device\n");
- return -EINVAL;
-}
-static DRIVER_ATTR_WO(remove);
-
-static struct attribute * netiucv_drv_attrs[] = {
- &driver_attr_connection.attr,
- &driver_attr_remove.attr,
- NULL,
-};
-
-static struct attribute_group netiucv_drv_attr_group = {
- .attrs = netiucv_drv_attrs,
-};
-
-static const struct attribute_group *netiucv_drv_attr_groups[] = {
- &netiucv_drv_attr_group,
- NULL,
-};
-
-static void netiucv_banner(void)
-{
- pr_info("driver initialized\n");
-}
-
-static void __exit netiucv_exit(void)
-{
- struct iucv_connection *cp;
- struct net_device *ndev;
- struct netiucv_priv *priv;
- struct device *dev;
-
- IUCV_DBF_TEXT(trace, 3, __func__);
- while (!list_empty(&iucv_connection_list)) {
- cp = list_entry(iucv_connection_list.next,
- struct iucv_connection, list);
- ndev = cp->netdev;
- priv = netdev_priv(ndev);
- dev = priv->dev;
-
- unregister_netdev(ndev);
- netiucv_unregister_device(dev);
- }
-
- driver_unregister(&netiucv_driver);
- iucv_unregister(&netiucv_handler, 1);
- iucv_unregister_dbf_views();
-
- pr_info("driver unloaded\n");
- return;
-}
-
-static int __init netiucv_init(void)
-{
- int rc;
-
- rc = iucv_register_dbf_views();
- if (rc)
- goto out;
- rc = iucv_register(&netiucv_handler, 1);
- if (rc)
- goto out_dbf;
- IUCV_DBF_TEXT(trace, 3, __func__);
- netiucv_driver.groups = netiucv_drv_attr_groups;
- rc = driver_register(&netiucv_driver);
- if (rc) {
- IUCV_DBF_TEXT_(setup, 2, "ret %d from driver_register\n", rc);
- goto out_iucv;
- }
-
- netiucv_banner();
- return rc;
-
-out_iucv:
- iucv_unregister(&netiucv_handler, 1);
-out_dbf:
- iucv_unregister_dbf_views();
-out:
- return rc;
-}
-
-module_init(netiucv_init);
-module_exit(netiucv_exit);
-MODULE_LICENSE("GPL");
diff --git a/drivers/s390/net/qeth_core_main.c b/drivers/s390/net/qeth_core_main.c
index fe9f48c315d9..edc0bcd46923 100644
--- a/drivers/s390/net/qeth_core_main.c
+++ b/drivers/s390/net/qeth_core_main.c
@@ -11,6 +11,7 @@
#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
#include <linux/compat.h>
+#include <linux/export.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/string.h>
diff --git a/drivers/s390/net/qeth_core_sys.c b/drivers/s390/net/qeth_core_sys.c
index eea93f8f106f..c0e4883be6d0 100644
--- a/drivers/s390/net/qeth_core_sys.c
+++ b/drivers/s390/net/qeth_core_sys.c
@@ -518,28 +518,32 @@ static ssize_t qeth_hw_trap_store(struct device *dev,
if (qeth_card_hw_is_reachable(card))
state = 1;
- if (sysfs_streq(buf, "arm") && !card->info.hwtrap) {
- if (state) {
+ if (sysfs_streq(buf, "arm")) {
+ if (state && !card->info.hwtrap) {
if (qeth_is_diagass_supported(card,
QETH_DIAGS_CMD_TRAP)) {
rc = qeth_hw_trap(card, QETH_DIAGS_TRAP_ARM);
if (!rc)
card->info.hwtrap = 1;
- } else
+ } else {
rc = -EINVAL;
- } else
+ }
+ } else {
card->info.hwtrap = 1;
- } else if (sysfs_streq(buf, "disarm") && card->info.hwtrap) {
- if (state) {
+ }
+ } else if (sysfs_streq(buf, "disarm")) {
+ if (state && card->info.hwtrap) {
rc = qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
if (!rc)
card->info.hwtrap = 0;
- } else
+ } else {
card->info.hwtrap = 0;
- } else if (sysfs_streq(buf, "trap") && state && card->info.hwtrap)
+ }
+ } else if (sysfs_streq(buf, "trap") && state && card->info.hwtrap) {
rc = qeth_hw_trap(card, QETH_DIAGS_TRAP_CAPTURE);
- else
+ } else {
rc = -EINVAL;
+ }
mutex_unlock(&card->conf_mutex);
return rc ? rc : count;
diff --git a/drivers/s390/net/qeth_l2_main.c b/drivers/s390/net/qeth_l2_main.c
index 777404d66e0c..2a3888283a94 100644
--- a/drivers/s390/net/qeth_l2_main.c
+++ b/drivers/s390/net/qeth_l2_main.c
@@ -10,6 +10,7 @@
#define KMSG_COMPONENT "qeth"
#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
+#include <linux/export.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/string.h>
diff --git a/drivers/s390/net/qeth_l3_main.c b/drivers/s390/net/qeth_l3_main.c
index 04c64ce0a1ca..3525be819362 100644
--- a/drivers/s390/net/qeth_l3_main.c
+++ b/drivers/s390/net/qeth_l3_main.c
@@ -10,6 +10,7 @@
#define KMSG_COMPONENT "qeth"
#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
+#include <linux/export.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/bitops.h>
diff --git a/drivers/s390/net/smsgiucv.c b/drivers/s390/net/smsgiucv.c
index c68ba8dbc014..3dadaacc42a6 100644
--- a/drivers/s390/net/smsgiucv.c
+++ b/drivers/s390/net/smsgiucv.c
@@ -7,6 +7,7 @@
* Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com)
*/
+#include <linux/export.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/errno.h>
generated by cgit v1.2.3 (git 2.39.0) at 2025-10-05 21:55:55 +0300