Quelle  ctcm_main.h   Sprache: C

/* SPDX-License-Identifier: GPL-2.0 */
/*
 * Copyright IBM Corp. 2001, 2007
 * Authors: Fritz Elfert (felfert@millenux.com)
 * Peter Tiedemann (ptiedem@de.ibm.com)
 */

#ifndef _CTCM_MAIN_H_
#define _CTCM_MAIN_H_

#include <asm/ccwdev.h>
#include <asm/ccwgroup.h>

#include <linux/skbuff.h>
#include <linux/netdevice.h>

#include "fsm.h"
#include "ctcm_dbug.h"
#include "ctcm_mpc.h"

#define CTC_DRIVER_NAME "ctcm"
#define CTC_DEVICE_NAME "ctc"
#define MPC_DEVICE_NAME "mpc"
#define CTC_DEVICE_GENE CTC_DEVICE_NAME "%d"
#define MPC_DEVICE_GENE MPC_DEVICE_NAME "%d"

#define CHANNEL_FLAGS_READ 0
#define CHANNEL_FLAGS_WRITE 1
#define CHANNEL_FLAGS_INUSE 2
#define CHANNEL_FLAGS_BUFSIZE_CHANGED 4
#define CHANNEL_FLAGS_FAILED 8
#define CHANNEL_FLAGS_WAITIRQ 16
#define CHANNEL_FLAGS_RWMASK 1
#define CHANNEL_DIRECTION(f) (f & CHANNEL_FLAGS_RWMASK)

#define LOG_FLAG_ILLEGALPKT 1
#define LOG_FLAG_ILLEGALSIZE 2
#define LOG_FLAG_OVERRUN 4
#define LOG_FLAG_NOMEM  8

#define ctcm_pr_debug(fmt, arg...) printk(KERN_DEBUG fmt, ##arg)

#define CTCM_PR_DEBUG(fmt, arg...) \
 do { \
  if (do_debug) \
   printk(KERN_DEBUG fmt, ##arg); \
 } while (0)

#define CTCM_PR_DBGDATA(fmt, arg...) \
 do { \
  if (do_debug_data) \
   printk(KERN_DEBUG fmt, ##arg); \
 } while (0)

#define CTCM_D3_DUMP(buf, len) \
 do { \
  if (do_debug_data) \
   ctcmpc_dumpit(buf, len); \
 } while (0)

#define CTCM_CCW_DUMP(buf, len) \
 do { \
  if (do_debug_ccw) \
   ctcmpc_dumpit(buf, len); \
 } while (0)

/**
 * Enum for classifying detected devices
 */
enum ctcm_channel_types {
 /* Device is not a channel  */
 ctcm_channel_type_none,

 /* Device is a CTC/A */
 ctcm_channel_type_parallel,

 /* Device is a FICON channel */
 ctcm_channel_type_ficon,

 /* Device is a ESCON channel */
 ctcm_channel_type_escon
};

/*
 * CCW commands, used in this driver.
 */
#define CCW_CMD_WRITE  0x01
#define CCW_CMD_READ  0x02
#define CCW_CMD_NOOP  0x03
#define CCW_CMD_TIC             0x08
#define CCW_CMD_SENSE_CMD 0x14
#define CCW_CMD_WRITE_CTL 0x17
#define CCW_CMD_SET_EXTENDED 0xc3
#define CCW_CMD_PREPARE  0xe3

#define CTCM_PROTO_S390  0
#define CTCM_PROTO_LINUX 1
#define CTCM_PROTO_LINUX_TTY 2
#define CTCM_PROTO_OS390 3
#define CTCM_PROTO_MPC  4
#define CTCM_PROTO_MAX  4

#define CTCM_STATSIZE_LIMIT 64
#define CTCM_BUFSIZE_LIMIT 65535
#define CTCM_BUFSIZE_DEFAULT 32768
#define MPC_BUFSIZE_DEFAULT CTCM_BUFSIZE_LIMIT

#define CTCM_TIME_1_SEC  1000
#define CTCM_TIME_5_SEC  5000
#define CTCM_TIME_10_SEC 10000

#define CTCM_INITIAL_BLOCKLEN 2

#define CTCM_READ  0
#define CTCM_WRITE  1

#define CTCM_ID_SIZE  20+3

struct ctcm_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;
};

/*
 * Definition of one channel
 */
struct channel {
 struct channel *next;
 char id[CTCM_ID_SIZE];
 struct ccw_device *cdev;
 /*
 * Type of this channel.
 * CTC/A or Escon for valid channels.
 */
 enum ctcm_channel_types type;
 /*
 * Misc. flags. See CHANNEL_FLAGS_... below
 */
 __u32 flags;
 __u16 protocol;  /* protocol of this channel (4 = MPC) */
 /*
 * I/O and irq related stuff
 */
 struct ccw1 *ccw;
 struct irb *irb;
 /*
 * RX/TX buffer size
 */
 int max_bufsize;
 struct sk_buff *trans_skb; /* transmit/receive buffer */
 struct sk_buff_head io_queue; /* universal I/O queue */
 struct tasklet_struct ch_tasklet; /* MPC ONLY */
 /*
 * TX queue for collecting skb's during busy.
 */
 struct sk_buff_head collect_queue;
 /*
 * Amount of data in collect_queue.
 */
 int collect_len;
 /*
 * spinlock for collect_queue and collect_len
 */
 spinlock_t collect_lock;
 /*
 * Timer for detecting unresposive
 * I/O operations.
 */
 fsm_timer timer;
 /* MPC ONLY section begin */
 __u32 th_seq_num; /* SNA TH seq number */
 __u8 th_seg;
 __u32 pdu_seq;
 struct sk_buff  *xid_skb;
 char   *xid_skb_data;
 struct th_header *xid_th;
 struct xid2  *xid;
 char   *xid_id;
 struct th_header *rcvd_xid_th;
 struct xid2  *rcvd_xid;
 char   *rcvd_xid_id;
 __u8   in_mpcgroup;
 fsm_timer  sweep_timer;
 struct sk_buff_head sweep_queue;
 struct th_header *discontact_th;
 struct tasklet_struct ch_disc_tasklet;
 /* MPC ONLY section end */

 int retry;  /* retry counter for misc. operations */
 fsm_instance *fsm; /* finite state machine of this channel */
 struct net_device *netdev; /* corresponding net_device */
 struct ctcm_profile prof;
 __u8 *trans_skb_data;
 __u16 logflags;
 __u8  sense_rc; /* last unit check sense code report control */
};

struct ctcm_priv {
 struct net_device_stats stats;
 unsigned long tbusy;

 /* The MPC group struct of this interface */
 struct mpc_group *mpcg; /* MPC only */
 struct xid2  *xid; /* MPC only */

 /* The finite state machine of this interface */
 fsm_instance *fsm;

 /* The protocol of this device */
 __u16 protocol;

 /* Timer for restarting after I/O Errors */
 fsm_timer restart_timer;

 int buffer_size; /* ctc only */

 struct channel *channel[2];
};

int ctcm_open(struct net_device *dev);
int ctcm_close(struct net_device *dev);

extern const struct attribute_group *ctcm_attr_groups[];

/*
 * Compatibility macros for busy handling
 * of network devices.
 */
static inline void ctcm_clear_busy_do(struct net_device *dev)
{
 clear_bit(0, &(((struct ctcm_priv *)dev->ml_priv)->tbusy));
 netif_wake_queue(dev);
}

static inline void ctcm_clear_busy(struct net_device *dev)
{
 struct mpc_group *grp;
 grp = ((struct ctcm_priv *)dev->ml_priv)->mpcg;

 if (!(grp && grp->in_sweep))
  ctcm_clear_busy_do(dev);
}


static inline int ctcm_test_and_set_busy(struct net_device *dev)
{
 netif_stop_queue(dev);
 return test_and_set_bit(0,
   &(((struct ctcm_priv *)dev->ml_priv)->tbusy));
}

extern int loglevel;
extern struct channel *channels;

void ctcm_unpack_skb(struct channel *ch, struct sk_buff *pskb);

/*
 * Functions related to setup and device detection.
 */

static inline int ctcm_less_than(char *id1, char *id2)
{
 unsigned long dev1, dev2;

 id1 = id1 + 5;
 id2 = id2 + 5;

 dev1 = simple_strtoul(id1, &id1, 16);
 dev2 = simple_strtoul(id2, &id2, 16);

 return (dev1 < dev2);
}

int ctcm_ch_alloc_buffer(struct channel *ch);

static inline int ctcm_checkalloc_buffer(struct channel *ch)
{
 if (ch->trans_skb == NULL)
  return ctcm_ch_alloc_buffer(ch);
 if (ch->flags & CHANNEL_FLAGS_BUFSIZE_CHANGED) {
  dev_kfree_skb(ch->trans_skb);
  return ctcm_ch_alloc_buffer(ch);
 }
 return 0;
}

struct mpc_group *ctcmpc_init_mpc_group(struct ctcm_priv *priv);

/* test if protocol attribute (of struct ctcm_priv or struct channel)
 * has MPC protocol setting. Type is not checked
 */
#define IS_MPC(p) ((p)->protocol == CTCM_PROTO_MPC)

/* test if struct ctcm_priv of struct net_device has MPC protocol setting */
#define IS_MPCDEV(dev) IS_MPC((struct ctcm_priv *)dev->ml_priv)

/*
 * Definition of our link level header.
 */
struct ll_header {
 __u16 length;
 __u16 type;
 __u16 unused;
};
#define LL_HEADER_LENGTH (sizeof(struct ll_header))

#endif