1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* 3 * Copyright IBM Corp. 2001, 2007 4 * Authors: Fritz Elfert (felfert@millenux.com) 5 * Peter Tiedemann (ptiedem@de.ibm.com) 6 */ 7 8 #ifndef _CTCM_MAIN_H_ 9 #define _CTCM_MAIN_H_ 10 11 #include <asm/ccwdev.h> 12 #include <asm/ccwgroup.h> 13 14 #include <linux/skbuff.h> 15 #include <linux/netdevice.h> 16 17 #include "fsm.h" 18 #include "ctcm_dbug.h" 19 #include "ctcm_mpc.h" 20 21 #define CTC_DRIVER_NAME "ctcm" 22 #define CTC_DEVICE_NAME "ctc" 23 #define MPC_DEVICE_NAME "mpc" 24 #define CTC_DEVICE_GENE CTC_DEVICE_NAME "%d" 25 #define MPC_DEVICE_GENE MPC_DEVICE_NAME "%d" 26 27 #define CHANNEL_FLAGS_READ 0 28 #define CHANNEL_FLAGS_WRITE 1 29 #define CHANNEL_FLAGS_INUSE 2 30 #define CHANNEL_FLAGS_BUFSIZE_CHANGED 4 31 #define CHANNEL_FLAGS_FAILED 8 32 #define CHANNEL_FLAGS_WAITIRQ 16 33 #define CHANNEL_FLAGS_RWMASK 1 34 #define CHANNEL_DIRECTION(f) (f & CHANNEL_FLAGS_RWMASK) 35 36 #define LOG_FLAG_ILLEGALPKT 1 37 #define LOG_FLAG_ILLEGALSIZE 2 38 #define LOG_FLAG_OVERRUN 4 39 #define LOG_FLAG_NOMEM 8 40 41 #define ctcm_pr_debug(fmt, arg...) printk(KERN_DEBUG fmt, ##arg) 42 43 #define CTCM_PR_DEBUG(fmt, arg...) \ 44 do { \ 45 if (do_debug) \ 46 printk(KERN_DEBUG fmt, ##arg); \ 47 } while (0) 48 49 #define CTCM_PR_DBGDATA(fmt, arg...) \ 50 do { \ 51 if (do_debug_data) \ 52 printk(KERN_DEBUG fmt, ##arg); \ 53 } while (0) 54 55 #define CTCM_D3_DUMP(buf, len) \ 56 do { \ 57 if (do_debug_data) \ 58 ctcmpc_dumpit(buf, len); \ 59 } while (0) 60 61 #define CTCM_CCW_DUMP(buf, len) \ 62 do { \ 63 if (do_debug_ccw) \ 64 ctcmpc_dumpit(buf, len); \ 65 } while (0) 66 67 /** 68 * Enum for classifying detected devices 69 */ 70 enum ctcm_channel_types { 71 /* Device is not a channel */ 72 ctcm_channel_type_none, 73 74 /* Device is a CTC/A */ 75 ctcm_channel_type_parallel, 76 77 /* Device is a FICON channel */ 78 ctcm_channel_type_ficon, 79 80 /* Device is a ESCON channel */ 81 ctcm_channel_type_escon 82 }; 83 84 /* 85 * CCW commands, used in this driver. 86 */ 87 #define CCW_CMD_WRITE 0x01 88 #define CCW_CMD_READ 0x02 89 #define CCW_CMD_NOOP 0x03 90 #define CCW_CMD_TIC 0x08 91 #define CCW_CMD_SENSE_CMD 0x14 92 #define CCW_CMD_WRITE_CTL 0x17 93 #define CCW_CMD_SET_EXTENDED 0xc3 94 #define CCW_CMD_PREPARE 0xe3 95 96 #define CTCM_PROTO_S390 0 97 #define CTCM_PROTO_LINUX 1 98 #define CTCM_PROTO_LINUX_TTY 2 99 #define CTCM_PROTO_OS390 3 100 #define CTCM_PROTO_MPC 4 101 #define CTCM_PROTO_MAX 4 102 103 #define CTCM_BUFSIZE_LIMIT 65535 104 #define CTCM_BUFSIZE_DEFAULT 32768 105 #define MPC_BUFSIZE_DEFAULT CTCM_BUFSIZE_LIMIT 106 107 #define CTCM_TIME_1_SEC 1000 108 #define CTCM_TIME_5_SEC 5000 109 #define CTCM_TIME_10_SEC 10000 110 111 #define CTCM_INITIAL_BLOCKLEN 2 112 113 #define CTCM_READ 0 114 #define CTCM_WRITE 1 115 116 #define CTCM_ID_SIZE 20+3 117 118 struct ctcm_profile { 119 unsigned long maxmulti; 120 unsigned long maxcqueue; 121 unsigned long doios_single; 122 unsigned long doios_multi; 123 unsigned long txlen; 124 unsigned long tx_time; 125 unsigned long send_stamp; 126 }; 127 128 /* 129 * Definition of one channel 130 */ 131 struct channel { 132 struct channel *next; 133 char id[CTCM_ID_SIZE]; 134 struct ccw_device *cdev; 135 /* 136 * Type of this channel. 137 * CTC/A or Escon for valid channels. 138 */ 139 enum ctcm_channel_types type; 140 /* 141 * Misc. flags. See CHANNEL_FLAGS_... below 142 */ 143 __u32 flags; 144 __u16 protocol; /* protocol of this channel (4 = MPC) */ 145 /* 146 * I/O and irq related stuff 147 */ 148 struct ccw1 *ccw; 149 struct irb *irb; 150 /* 151 * RX/TX buffer size 152 */ 153 int max_bufsize; 154 struct sk_buff *trans_skb; /* transmit/receive buffer */ 155 struct sk_buff_head io_queue; /* universal I/O queue */ 156 struct tasklet_struct ch_tasklet; /* MPC ONLY */ 157 /* 158 * TX queue for collecting skb's during busy. 159 */ 160 struct sk_buff_head collect_queue; 161 /* 162 * Amount of data in collect_queue. 163 */ 164 int collect_len; 165 /* 166 * spinlock for collect_queue and collect_len 167 */ 168 spinlock_t collect_lock; 169 /* 170 * Timer for detecting unresposive 171 * I/O operations. 172 */ 173 fsm_timer timer; 174 /* MPC ONLY section begin */ 175 __u32 th_seq_num; /* SNA TH seq number */ 176 __u8 th_seg; 177 __u32 pdu_seq; 178 struct sk_buff *xid_skb; 179 char *xid_skb_data; 180 struct th_header *xid_th; 181 struct xid2 *xid; 182 char *xid_id; 183 struct th_header *rcvd_xid_th; 184 struct xid2 *rcvd_xid; 185 char *rcvd_xid_id; 186 __u8 in_mpcgroup; 187 fsm_timer sweep_timer; 188 struct sk_buff_head sweep_queue; 189 struct th_header *discontact_th; 190 struct tasklet_struct ch_disc_tasklet; 191 /* MPC ONLY section end */ 192 193 int retry; /* retry counter for misc. operations */ 194 fsm_instance *fsm; /* finite state machine of this channel */ 195 struct net_device *netdev; /* corresponding net_device */ 196 struct ctcm_profile prof; 197 __u8 *trans_skb_data; 198 __u16 logflags; 199 __u8 sense_rc; /* last unit check sense code report control */ 200 }; 201 202 struct ctcm_priv { 203 struct net_device_stats stats; 204 unsigned long tbusy; 205 206 /* The MPC group struct of this interface */ 207 struct mpc_group *mpcg; /* MPC only */ 208 struct xid2 *xid; /* MPC only */ 209 210 /* The finite state machine of this interface */ 211 fsm_instance *fsm; 212 213 /* The protocol of this device */ 214 __u16 protocol; 215 216 /* Timer for restarting after I/O Errors */ 217 fsm_timer restart_timer; 218 219 int buffer_size; /* ctc only */ 220 221 struct channel *channel[2]; 222 }; 223 224 int ctcm_open(struct net_device *dev); 225 int ctcm_close(struct net_device *dev); 226 227 extern const struct attribute_group *ctcm_attr_groups[]; 228 229 /* 230 * Compatibility macros for busy handling 231 * of network devices. 232 */ 233 static inline void ctcm_clear_busy_do(struct net_device *dev) 234 { 235 clear_bit(0, &(((struct ctcm_priv *)dev->ml_priv)->tbusy)); 236 netif_wake_queue(dev); 237 } 238 239 static inline void ctcm_clear_busy(struct net_device *dev) 240 { 241 struct mpc_group *grp; 242 grp = ((struct ctcm_priv *)dev->ml_priv)->mpcg; 243 244 if (!(grp && grp->in_sweep)) 245 ctcm_clear_busy_do(dev); 246 } 247 248 249 static inline int ctcm_test_and_set_busy(struct net_device *dev) 250 { 251 netif_stop_queue(dev); 252 return test_and_set_bit(0, 253 &(((struct ctcm_priv *)dev->ml_priv)->tbusy)); 254 } 255 256 extern int loglevel; 257 extern struct channel *channels; 258 259 void ctcm_unpack_skb(struct channel *ch, struct sk_buff *pskb); 260 261 /* 262 * Functions related to setup and device detection. 263 */ 264 265 static inline int ctcm_less_than(char *id1, char *id2) 266 { 267 unsigned long dev1, dev2; 268 269 id1 = id1 + 5; 270 id2 = id2 + 5; 271 272 dev1 = simple_strtoul(id1, &id1, 16); 273 dev2 = simple_strtoul(id2, &id2, 16); 274 275 return (dev1 < dev2); 276 } 277 278 int ctcm_ch_alloc_buffer(struct channel *ch); 279 280 static inline int ctcm_checkalloc_buffer(struct channel *ch) 281 { 282 if (ch->trans_skb == NULL) 283 return ctcm_ch_alloc_buffer(ch); 284 if (ch->flags & CHANNEL_FLAGS_BUFSIZE_CHANGED) { 285 dev_kfree_skb(ch->trans_skb); 286 return ctcm_ch_alloc_buffer(ch); 287 } 288 return 0; 289 } 290 291 struct mpc_group *ctcmpc_init_mpc_group(struct ctcm_priv *priv); 292 293 /* test if protocol attribute (of struct ctcm_priv or struct channel) 294 * has MPC protocol setting. Type is not checked 295 */ 296 #define IS_MPC(p) ((p)->protocol == CTCM_PROTO_MPC) 297 298 /* test if struct ctcm_priv of struct net_device has MPC protocol setting */ 299 #define IS_MPCDEV(dev) IS_MPC((struct ctcm_priv *)dev->ml_priv) 300 301 static inline gfp_t gfp_type(void) 302 { 303 return in_interrupt() ? GFP_ATOMIC : GFP_KERNEL; 304 } 305 306 /* 307 * Definition of our link level header. 308 */ 309 struct ll_header { 310 __u16 length; 311 __u16 type; 312 __u16 unused; 313 }; 314 #define LL_HEADER_LENGTH (sizeof(struct ll_header)) 315 316 #endif 317