Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6
[linux-2.6.git] / drivers / s390 / net / claw.h
1 /*******************************************************
2 *  Define constants                                    *
3 *                                                      *
4 ********************************************************/
5
6 /*-----------------------------------------------------*
7 *     CCW command codes for CLAW protocol              *
8 *------------------------------------------------------*/
9
10 #define CCW_CLAW_CMD_WRITE           0x01      /* write - not including link */
11 #define CCW_CLAW_CMD_READ            0x02      /* read */
12 #define CCW_CLAW_CMD_NOP             0x03      /* NOP */
13 #define CCW_CLAW_CMD_SENSE           0x04      /* Sense */
14 #define CCW_CLAW_CMD_SIGNAL_SMOD     0x05      /* Signal Status Modifier */
15 #define CCW_CLAW_CMD_TIC             0x08      /* TIC */
16 #define CCW_CLAW_CMD_READHEADER      0x12      /* read header data */
17 #define CCW_CLAW_CMD_READFF          0x22      /* read an FF */
18 #define CCW_CLAW_CMD_SENSEID         0xe4      /* Sense ID */
19
20
21 /*-----------------------------------------------------*
22 *    CLAW Unique constants                             *
23 *------------------------------------------------------*/
24
25 #define MORE_to_COME_FLAG       0x04   /* OR with write CCW in case of m-t-c */
26 #define CLAW_IDLE               0x00   /* flag to indicate CLAW is idle */
27 #define CLAW_BUSY               0xff   /* flag to indicate CLAW is busy */
28 #define CLAW_PENDING            0x00   /* flag to indicate i/o is pending */
29 #define CLAW_COMPLETE           0xff   /* flag to indicate i/o completed */
30
31 /*-----------------------------------------------------*
32 *     CLAW control command code                        *
33 *------------------------------------------------------*/
34
35 #define SYSTEM_VALIDATE_REQUEST   0x01  /* System Validate request */
36 #define SYSTEM_VALIDATE_RESPONSE  0x02  /* System Validate response */
37 #define CONNECTION_REQUEST        0x21  /* Connection request */
38 #define CONNECTION_RESPONSE       0x22  /* Connection response */
39 #define CONNECTION_CONFIRM        0x23  /* Connection confirm */
40 #define DISCONNECT                0x24  /* Disconnect */
41 #define CLAW_ERROR                0x41  /* CLAW error message */
42 #define CLAW_VERSION_ID           2     /* CLAW version ID */
43
44 /*-----------------------------------------------------*
45 *  CLAW adater sense bytes                             *
46 *------------------------------------------------------*/
47
48 #define CLAW_ADAPTER_SENSE_BYTE 0x41   /* Stop command issued to adapter */
49
50 /*-----------------------------------------------------*
51 *      CLAW control command return codes               *
52 *------------------------------------------------------*/
53
54 #define CLAW_RC_NAME_MISMATCH       166  /*  names do not match */
55 #define CLAW_RC_WRONG_VERSION       167  /*  wrong CLAW version number */
56 #define CLAW_RC_HOST_RCV_TOO_SMALL  180  /*  Host maximum receive is   */
57                                          /*  less than Linux on zSeries*/
58                                          /*  transmit size             */
59
60 /*-----------------------------------------------------*
61 *      CLAW Constants application name                 *
62 *------------------------------------------------------*/
63
64 #define HOST_APPL_NAME          "TCPIP   "
65 #define WS_APPL_NAME_IP_LINK    "TCPIP   "
66 #define WS_APPL_NAME_IP_NAME    "IP      "
67 #define WS_APPL_NAME_API_LINK   "API     "
68 #define WS_APPL_NAME_PACKED     "PACKED  "
69 #define WS_NAME_NOT_DEF         "NOT_DEF "
70 #define PACKING_ASK             1
71 #define PACK_SEND               2
72 #define DO_PACKED               3
73
74 #define MAX_ENVELOPE_SIZE       65536
75 #define CLAW_DEFAULT_MTU_SIZE   4096
76 #define DEF_PACK_BUFSIZE        32768
77 #define READ_CHANNEL            0
78 #define WRITE_CHANNEL           1
79
80 #define TB_TX                   0          /* sk buffer handling in process  */
81 #define TB_STOP                 1          /* network device stop in process */
82 #define TB_RETRY                2          /* retry in process               */
83 #define TB_NOBUFFER             3          /* no buffer on free queue        */
84 #define CLAW_MAX_LINK_ID        1
85 #define CLAW_MAX_DEV            256        /*      max claw devices          */
86 #define MAX_NAME_LEN            8          /* host name, adapter name length */
87 #define CLAW_FRAME_SIZE         4096
88 #define CLAW_ID_SIZE            20+3
89
90 /* state machine codes used in claw_irq_handler */
91
92 #define CLAW_STOP                0
93 #define CLAW_START_HALT_IO       1
94 #define CLAW_START_SENSEID       2
95 #define CLAW_START_READ          3
96 #define CLAW_START_WRITE         4
97
98 /*-----------------------------------------------------*
99 *    Lock flag                                         *
100 *------------------------------------------------------*/
101 #define LOCK_YES             0
102 #define LOCK_NO              1
103
104 /*-----------------------------------------------------*
105 *    DBF Debug macros                                  *
106 *------------------------------------------------------*/
107 #define CLAW_DBF_TEXT(level, name, text) \
108         do { \
109                 debug_text_event(claw_dbf_##name, level, text); \
110         } while (0)
111
112 #define CLAW_DBF_HEX(level,name,addr,len) \
113 do { \
114         debug_event(claw_dbf_##name,level,(void*)(addr),len); \
115 } while (0)
116
117 /* Allow to sort out low debug levels early to avoid wasted sprints */
118 static inline int claw_dbf_passes(debug_info_t *dbf_grp, int level)
119 {
120         return (level <= dbf_grp->level);
121 }
122
123 #define CLAW_DBF_TEXT_(level,name,text...) \
124         do { \
125                 if (claw_dbf_passes(claw_dbf_##name, level)) { \
126                         sprintf(debug_buffer, text); \
127                         debug_text_event(claw_dbf_##name, level, \
128                                                 debug_buffer); \
129                 } \
130         } while (0)
131
132 /**
133  * Enum for classifying detected devices.
134  */
135 enum claw_channel_types {
136         /* Device is not a channel  */
137         claw_channel_type_none,
138
139         /* Device is a CLAW channel device */
140         claw_channel_type_claw
141 };
142
143
144 /*******************************************************
145 *  Define Control Blocks                               *
146 *                                                      *
147 ********************************************************/
148
149 /*------------------------------------------------------*/
150 /*     CLAW header                                      */
151 /*------------------------------------------------------*/
152
153 struct clawh {
154         __u16  length;     /* length of data read by preceding read CCW */
155         __u8   opcode;     /* equivalent read CCW */
156         __u8   flag;       /* flag of FF to indicate read was completed */
157 };
158
159 /*------------------------------------------------------*/
160 /*     CLAW Packing header   4 bytes                    */
161 /*------------------------------------------------------*/
162 struct clawph {
163        __u16 len;       /* Length of Packed Data Area   */
164        __u8  flag;      /* Reserved not used            */
165        __u8  link_num;  /* Link ID                      */
166 };
167
168 /*------------------------------------------------------*/
169 /*     CLAW Ending struct ccwbk                         */
170 /*------------------------------------------------------*/
171 struct endccw {
172         __u32     real;            /* real address of this block */
173        __u8      write1;          /* write 1 is active */
174         __u8      read1;           /* read 1 is active  */
175         __u16     reserved;        /* reserved for future use */
176         struct ccw1    write1_nop1;
177         struct ccw1    write1_nop2;
178         struct ccw1    write2_nop1;
179         struct ccw1    write2_nop2;
180         struct ccw1    read1_nop1;
181         struct ccw1    read1_nop2;
182         struct ccw1    read2_nop1;
183         struct ccw1    read2_nop2;
184 };
185
186 /*------------------------------------------------------*/
187 /*     CLAW struct ccwbk                                       */
188 /*------------------------------------------------------*/
189 struct ccwbk {
190         void   *next;        /* pointer to next ccw block */
191         __u32     real;         /* real address of this ccw */
192         void      *p_buffer;    /* virtual address of data */
193         struct clawh     header;       /* claw header */
194         struct ccw1    write;   /* write CCW    */
195         struct ccw1    w_read_FF; /* read FF */
196         struct ccw1    w_TIC_1;        /* TIC */
197         struct ccw1    read;         /* read CCW  */
198         struct ccw1    read_h;        /* read header */
199         struct ccw1    signal;       /* signal SMOD  */
200         struct ccw1    r_TIC_1;        /* TIC1 */
201         struct ccw1    r_read_FF;      /* read FF  */
202         struct ccw1    r_TIC_2;        /* TIC2 */
203 };
204
205 /*------------------------------------------------------*/
206 /*     CLAW control block                               */
207 /*------------------------------------------------------*/
208 struct clawctl {
209         __u8    command;      /* control command */
210         __u8    version;      /* CLAW protocol version */
211         __u8    linkid;       /* link ID   */
212         __u8    correlator;   /* correlator */
213         __u8    rc;           /* return code */
214         __u8    reserved1;    /* reserved */
215         __u8    reserved2;    /* reserved */
216         __u8    reserved3;    /* reserved */
217         __u8    data[24];     /* command specific fields */
218 };
219
220 /*------------------------------------------------------*/
221 /*     Data for SYSTEMVALIDATE command                  */
222 /*------------------------------------------------------*/
223 struct sysval  {
224         char    WS_name[8];        /* Workstation System name  */
225         char    host_name[8];      /* Host system name     */
226         __u16   read_frame_size;   /* read frame size */
227         __u16   write_frame_size;  /* write frame size */
228         __u8    reserved[4];       /* reserved */
229 };
230
231 /*------------------------------------------------------*/
232 /*     Data for Connect command                         */
233 /*------------------------------------------------------*/
234 struct conncmd  {
235         char     WS_name[8];       /* Workstation application name  */
236         char     host_name[8];     /* Host application name      */
237         __u16    reserved1[2];     /* read frame size */
238         __u8     reserved2[4];     /* reserved  */
239 };
240
241 /*------------------------------------------------------*/
242 /*     Data for CLAW error                              */
243 /*------------------------------------------------------*/
244 struct clawwerror  {
245         char      reserved1[8];   /* reserved */
246         char      reserved2[8];   /* reserved  */
247         char      reserved3[8];   /* reserved  */
248 };
249
250 /*------------------------------------------------------*/
251 /*     Data buffer for CLAW                             */
252 /*------------------------------------------------------*/
253 struct clawbuf  {
254        char      buffer[MAX_ENVELOPE_SIZE];   /* data buffer */
255 };
256
257 /*------------------------------------------------------*/
258 /*     Channel control block for read and write channel */
259 /*------------------------------------------------------*/
260
261 struct chbk {
262         unsigned int        devno;
263         int                 irq;
264         char                id[CLAW_ID_SIZE];
265        __u32               IO_active;
266         __u8                claw_state;
267         struct irb          *irb;
268         struct ccw_device   *cdev;  /* pointer to the channel device */
269         struct net_device   *ndev;
270         wait_queue_head_t   wait;
271         struct tasklet_struct    tasklet;
272         struct timer_list   timer;
273         unsigned long       flag_a;    /* atomic flags */
274 #define CLAW_BH_ACTIVE      0
275         unsigned long       flag_b;    /* atomic flags */
276 #define CLAW_WRITE_ACTIVE   0
277         __u8                last_dstat;
278         __u8                flag;
279         struct sk_buff_head collect_queue;
280         spinlock_t collect_lock;
281 #define CLAW_WRITE      0x02      /* - Set if this is a write channel */
282 #define CLAW_READ       0x01      /* - Set if this is a read channel  */
283 #define CLAW_TIMER      0x80      /* - Set if timer made the wake_up  */
284 };
285
286 /*--------------------------------------------------------------*
287 *           CLAW  environment block                             *
288 *---------------------------------------------------------------*/
289
290 struct claw_env {
291         unsigned int            devno[2];       /* device number */
292         char                    host_name[9];   /* Host name */
293         char                    adapter_name [9]; /* adapter name */
294         char                    api_type[9];    /* TCPIP, API or PACKED */
295         void                    *p_priv;        /* privptr */
296         __u16                   read_buffers;   /* read buffer number */
297         __u16                   write_buffers;  /* write buffer number */
298         __u16                   read_size;      /* read buffer size */
299         __u16                   write_size;     /* write buffer size */
300         __u16                   dev_id;         /* device ident */
301         __u8                    packing;        /* are we packing? */
302         __u8                    in_use;         /* device active flag */
303         struct net_device       *ndev;          /* backward ptr to the net dev*/
304 };
305
306 /*--------------------------------------------------------------*
307 *           CLAW  main control block                            *
308 *---------------------------------------------------------------*/
309
310 struct claw_privbk {
311         void *p_buff_ccw;
312         __u32      p_buff_ccw_num;
313         void  *p_buff_read;
314         __u32      p_buff_read_num;
315         __u32      p_buff_pages_perread;
316         void  *p_buff_write;
317         __u32      p_buff_write_num;
318         __u32      p_buff_pages_perwrite;
319         long       active_link_ID;           /* Active logical link ID */
320         struct ccwbk *p_write_free_chain;     /* pointer to free ccw chain */
321         struct ccwbk *p_write_active_first;   /* ptr to the first write ccw */
322         struct ccwbk *p_write_active_last;    /* ptr to the last write ccw */
323         struct ccwbk *p_read_active_first;    /* ptr to the first read ccw */
324         struct ccwbk *p_read_active_last;     /* ptr to the last read ccw */
325         struct endccw *p_end_ccw;              /*ptr to ending ccw */
326         struct ccwbk *p_claw_signal_blk;      /* ptr to signal block */
327         __u32      write_free_count;       /* number of free bufs for write */
328         struct     net_device_stats  stats; /*   device status    */
329         struct chbk channel[2];            /* Channel control blocks */
330         __u8       mtc_skipping;
331         int        mtc_offset;
332         int        mtc_logical_link;
333         void       *p_mtc_envelope;
334         struct     sk_buff      *pk_skb;        /* packing buffer    */
335         int        pk_cnt;
336         struct clawctl ctl_bk;
337         struct claw_env *p_env;
338         __u8       system_validate_comp;
339         __u8       release_pend;
340         __u8      checksum_received_ip_pkts;
341         __u8      buffs_alloc;
342         struct endccw  end_ccw;
343         unsigned long  tbusy;
344
345 };
346
347
348 /************************************************************/
349 /* define global constants                                  */
350 /************************************************************/
351
352 #define CCWBK_SIZE sizeof(struct ccwbk)
353
354