?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] s390: broken null test in claw driver
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / s390 / net / claw.c
blob95f4e105cb969293934538df62228665a7e40d7a
1 /*
2 * drivers/s390/net/claw.c
3 * ESCON CLAW network driver
4 *
5 * Linux for zSeries version
6 * Copyright (C) 2002,2005 IBM Corporation
7 * Author(s) Original code written by:
8 * Kazuo Iimura (iimura@jp.ibm.com)
9 * Rewritten by
10 * Andy Richter (richtera@us.ibm.com)
11 * Marc Price (mwprice@us.ibm.com)
12 *
13 * sysfs parms:
14 * group x.x.rrrr,x.x.wwww
15 * read_buffer nnnnnnn
16 * write_buffer nnnnnn
17 * host_name aaaaaaaa
18 * adapter_name aaaaaaaa
19 * api_type aaaaaaaa
20 *
21 * eg.
22 * group 0.0.0200 0.0.0201
23 * read_buffer 25
24 * write_buffer 20
25 * host_name LINUX390
26 * adapter_name RS6K
27 * api_type TCPIP
28 *
29 * where
30 *
31 * The device id is decided by the order entries
32 * are added to the group the first is claw0 the second claw1
33 * up to CLAW_MAX_DEV
34 *
35 * rrrr - the first of 2 consecutive device addresses used for the
36 * CLAW protocol.
37 * The specified address is always used as the input (Read)
38 * channel and the next address is used as the output channel.
39 *
40 * wwww - the second of 2 consecutive device addresses used for
41 * the CLAW protocol.
42 * The specified address is always used as the output
43 * channel and the previous address is used as the input channel.
44 *
45 * read_buffer - specifies number of input buffers to allocate.
46 * write_buffer - specifies number of output buffers to allocate.
47 * host_name - host name
48 * adaptor_name - adaptor name
49 * api_type - API type TCPIP or API will be sent and expected
50 * as ws_name
51 *
52 * Note the following requirements:
53 * 1) host_name must match the configured adapter_name on the remote side
54 * 2) adaptor_name must match the configured host name on the remote side
55 *
56 * Change History
57 * 1.00 Initial release shipped
58 * 1.10 Changes for Buffer allocation
59 * 1.15 Changed for 2.6 Kernel No longer compiles on 2.4 or lower
60 * 1.25 Added Packing support
61 */
62 #include <asm/bitops.h>
63 #include <asm/ccwdev.h>
64 #include <asm/ccwgroup.h>
65 #include <asm/debug.h>
66 #include <asm/idals.h>
67 #include <asm/io.h>
68
69 #include <linux/ctype.h>
70 #include <linux/delay.h>
71 #include <linux/errno.h>
72 #include <linux/if_arp.h>
73 #include <linux/init.h>
74 #include <linux/interrupt.h>
75 #include <linux/ip.h>
76 #include <linux/kernel.h>
77 #include <linux/module.h>
78 #include <linux/netdevice.h>
79 #include <linux/etherdevice.h>
80 #include <linux/proc_fs.h>
81 #include <linux/sched.h>
82 #include <linux/signal.h>
83 #include <linux/skbuff.h>
84 #include <linux/slab.h>
85 #include <linux/string.h>
86 #include <linux/tcp.h>
87 #include <linux/timer.h>
88 #include <linux/types.h>
89
90 #include "cu3088.h"
91 #include "claw.h"
92
93 MODULE_AUTHOR("Andy Richter <richtera@us.ibm.com>");
94 MODULE_DESCRIPTION("Linux for zSeries CLAW Driver\n" \
95 "Copyright 2000,2005 IBM Corporation\n");
96 MODULE_LICENSE("GPL");
97
98 /* Debugging is based on DEBUGMSG, IOTRACE, or FUNCTRACE options:
99 DEBUGMSG - Enables output of various debug messages in the code
100 IOTRACE - Enables output of CCW and other IO related traces
101 FUNCTRACE - Enables output of function entry/exit trace
102 Define any combination of above options to enable tracing
103
104 CLAW also uses the s390dbf file system see claw_trace and claw_setup
105 */
106
107 /* following enables tracing */
108 //#define DEBUGMSG
109 //#define IOTRACE
110 //#define FUNCTRACE
111
112 #ifdef DEBUGMSG
113 #define DEBUG
114 #endif
115
116 #ifdef IOTRACE
117 #define DEBUG
118 #endif
119
120 #ifdef FUNCTRACE
121 #define DEBUG
122 #endif
123
124 char debug_buffer[255];
125 /**
126 * Debug Facility Stuff
127 */
128 static debug_info_t *claw_dbf_setup;
129 static debug_info_t *claw_dbf_trace;
130
131 /**
132 * CLAW Debug Facility functions
133 */
134 static void
135 claw_unregister_debug_facility(void)
136 {
137 if (claw_dbf_setup)
138 debug_unregister(claw_dbf_setup);
139 if (claw_dbf_trace)
140 debug_unregister(claw_dbf_trace);
141 }
142
143 static int
144 claw_register_debug_facility(void)
145 {
146 claw_dbf_setup = debug_register("claw_setup", 2, 1, 8);
147 claw_dbf_trace = debug_register("claw_trace", 2, 2, 8);
148 if (claw_dbf_setup == NULL || claw_dbf_trace == NULL) {
149 printk(KERN_WARNING "Not enough memory for debug facility.\n");
150 claw_unregister_debug_facility();
151 return -ENOMEM;
152 }
153 debug_register_view(claw_dbf_setup, &debug_hex_ascii_view);
154 debug_set_level(claw_dbf_setup, 2);
155 debug_register_view(claw_dbf_trace, &debug_hex_ascii_view);
156 debug_set_level(claw_dbf_trace, 2);
157 return 0;
158 }
159
160 static inline void
161 claw_set_busy(struct net_device *dev)
162 {
163 ((struct claw_privbk *) dev->priv)->tbusy=1;
164 eieio();
165 }
166
167 static inline void
168 claw_clear_busy(struct net_device *dev)
169 {
170 clear_bit(0, &(((struct claw_privbk *) dev->priv)->tbusy));
171 netif_wake_queue(dev);
172 eieio();
173 }
174
175 static inline int
176 claw_check_busy(struct net_device *dev)
177 {
178 eieio();
179 return ((struct claw_privbk *) dev->priv)->tbusy;
180 }
181
182 static inline void
183 claw_setbit_busy(int nr,struct net_device *dev)
184 {
185 netif_stop_queue(dev);
186 set_bit(nr, (void *)&(((struct claw_privbk *)dev->priv)->tbusy));
187 }
188
189 static inline void
190 claw_clearbit_busy(int nr,struct net_device *dev)
191 {
192 clear_bit(nr,(void *)&(((struct claw_privbk *)dev->priv)->tbusy));
193 netif_wake_queue(dev);
194 }
195
196 static inline int
197 claw_test_and_setbit_busy(int nr,struct net_device *dev)
198 {
199 netif_stop_queue(dev);
200 return test_and_set_bit(nr,
201 (void *)&(((struct claw_privbk *) dev->priv)->tbusy));
202 }
203
204
205 /* Functions for the DEV methods */
206
207 static int claw_probe(struct ccwgroup_device *cgdev);
208 static void claw_remove_device(struct ccwgroup_device *cgdev);
209 static void claw_purge_skb_queue(struct sk_buff_head *q);
210 static int claw_new_device(struct ccwgroup_device *cgdev);
211 static int claw_shutdown_device(struct ccwgroup_device *cgdev);
212 static int claw_tx(struct sk_buff *skb, struct net_device *dev);
213 static int claw_change_mtu( struct net_device *dev, int new_mtu);
214 static int claw_open(struct net_device *dev);
215 static void claw_irq_handler(struct ccw_device *cdev,
216 unsigned long intparm, struct irb *irb);
217 static void claw_irq_tasklet ( unsigned long data );
218 static int claw_release(struct net_device *dev);
219 static void claw_write_retry ( struct chbk * p_ch );
220 static void claw_write_next ( struct chbk * p_ch );
221 static void claw_timer ( struct chbk * p_ch );
222
223 /* Functions */
224 static int add_claw_reads(struct net_device *dev,
225 struct ccwbk* p_first, struct ccwbk* p_last);
226 static void inline ccw_check_return_code (struct ccw_device *cdev,
227 int return_code);
228 static void inline ccw_check_unit_check (struct chbk * p_ch,
229 unsigned char sense );
230 static int find_link(struct net_device *dev, char *host_name, char *ws_name );
231 static int claw_hw_tx(struct sk_buff *skb, struct net_device *dev, long linkid);
232 static int init_ccw_bk(struct net_device *dev);
233 static void probe_error( struct ccwgroup_device *cgdev);
234 static struct net_device_stats *claw_stats(struct net_device *dev);
235 static int inline pages_to_order_of_mag(int num_of_pages);
236 static struct sk_buff *claw_pack_skb(struct claw_privbk *privptr);
237 #ifdef DEBUG
238 static void dumpit (char *buf, int len);
239 #endif
240 /* sysfs Functions */
241 static ssize_t claw_hname_show(struct device *dev, struct device_attribute *attr, char *buf);
242 static ssize_t claw_hname_write(struct device *dev, struct device_attribute *attr,
243 const char *buf, size_t count);
244 static ssize_t claw_adname_show(struct device *dev, struct device_attribute *attr, char *buf);
245 static ssize_t claw_adname_write(struct device *dev, struct device_attribute *attr,
246 const char *buf, size_t count);
247 static ssize_t claw_apname_show(struct device *dev, struct device_attribute *attr, char *buf);
248 static ssize_t claw_apname_write(struct device *dev, struct device_attribute *attr,
249 const char *buf, size_t count);
250 static ssize_t claw_wbuff_show(struct device *dev, struct device_attribute *attr, char *buf);
251 static ssize_t claw_wbuff_write(struct device *dev, struct device_attribute *attr,
252 const char *buf, size_t count);
253 static ssize_t claw_rbuff_show(struct device *dev, struct device_attribute *attr, char *buf);
254 static ssize_t claw_rbuff_write(struct device *dev, struct device_attribute *attr,
255 const char *buf, size_t count);
256 static int claw_add_files(struct device *dev);
257 static void claw_remove_files(struct device *dev);
258
259 /* Functions for System Validate */
260 static int claw_process_control( struct net_device *dev, struct ccwbk * p_ccw);
261 static int claw_send_control(struct net_device *dev, __u8 type, __u8 link,
262 __u8 correlator, __u8 rc , char *local_name, char *remote_name);
263 static int claw_snd_conn_req(struct net_device *dev, __u8 link);
264 static int claw_snd_disc(struct net_device *dev, struct clawctl * p_ctl);
265 static int claw_snd_sys_validate_rsp(struct net_device *dev,
266 struct clawctl * p_ctl, __u32 return_code);
267 static int claw_strt_conn_req(struct net_device *dev );
268 static void claw_strt_read ( struct net_device *dev, int lock );
269 static void claw_strt_out_IO( struct net_device *dev );
270 static void claw_free_wrt_buf( struct net_device *dev );
271
272 /* Functions for unpack reads */
273 static void unpack_read (struct net_device *dev );
274
275 /* ccwgroup table */
276
277 static struct ccwgroup_driver claw_group_driver = {
278 .owner = THIS_MODULE,
279 .name = "claw",
280 .max_slaves = 2,
281 .driver_id = 0xC3D3C1E6,
282 .probe = claw_probe,
283 .remove = claw_remove_device,
284 .set_online = claw_new_device,
285 .set_offline = claw_shutdown_device,
286 };
287
288 /*
289 *
290 * Key functions
291 */
292
293 /*----------------------------------------------------------------*
294 * claw_probe *
295 * this function is called for each CLAW device. *
296 *----------------------------------------------------------------*/
297 static int
298 claw_probe(struct ccwgroup_device *cgdev)
299 {
300 int rc;
301 struct claw_privbk *privptr=NULL;
302
303 #ifdef FUNCTRACE
304 printk(KERN_INFO "%s Enter\n",__FUNCTION__);
305 #endif
306 CLAW_DBF_TEXT(2,setup,"probe");
307 if (!get_device(&cgdev->dev))
308 return -ENODEV;
309 #ifdef DEBUGMSG
310 printk(KERN_INFO "claw: variable cgdev =\n");
311 dumpit((char *)cgdev, sizeof(struct ccwgroup_device));
312 #endif
313 privptr = kzalloc(sizeof(struct claw_privbk), GFP_KERNEL);
314 if (privptr == NULL) {
315 probe_error(cgdev);
316 put_device(&cgdev->dev);
317 printk(KERN_WARNING "Out of memory %s %s Exit Line %d \n",
318 cgdev->cdev[0]->dev.bus_id,__FUNCTION__,__LINE__);
319 CLAW_DBF_TEXT_(2,setup,"probex%d",-ENOMEM);
320 return -ENOMEM;
321 }
322 privptr->p_mtc_envelope= kmalloc( MAX_ENVELOPE_SIZE, GFP_KERNEL);
323 privptr->p_env = kmalloc(sizeof(struct claw_env), GFP_KERNEL);
324 if ((privptr->p_mtc_envelope==NULL) || (privptr->p_env==NULL)) {
325 probe_error(cgdev);
326 put_device(&cgdev->dev);
327 printk(KERN_WARNING "Out of memory %s %s Exit Line %d \n",
328 cgdev->cdev[0]->dev.bus_id,__FUNCTION__,__LINE__);
329 CLAW_DBF_TEXT_(2,setup,"probex%d",-ENOMEM);
330 return -ENOMEM;
331 }
332 memset(privptr->p_mtc_envelope, 0x00, MAX_ENVELOPE_SIZE);
333 memset(privptr->p_env, 0x00, sizeof(struct claw_env));
334 memcpy(privptr->p_env->adapter_name,WS_NAME_NOT_DEF,8);
335 memcpy(privptr->p_env->host_name,WS_NAME_NOT_DEF,8);
336 memcpy(privptr->p_env->api_type,WS_NAME_NOT_DEF,8);
337 privptr->p_env->packing = 0;
338 privptr->p_env->write_buffers = 5;
339 privptr->p_env->read_buffers = 5;
340 privptr->p_env->read_size = CLAW_FRAME_SIZE;
341 privptr->p_env->write_size = CLAW_FRAME_SIZE;
342 rc = claw_add_files(&cgdev->dev);
343 if (rc) {
344 probe_error(cgdev);
345 put_device(&cgdev->dev);
346 printk(KERN_WARNING "add_files failed %s %s Exit Line %d \n",
347 cgdev->cdev[0]->dev.bus_id,__FUNCTION__,__LINE__);
348 CLAW_DBF_TEXT_(2,setup,"probex%d",rc);
349 return rc;
350 }
351 printk(KERN_INFO "claw: sysfs files added for %s\n",cgdev->cdev[0]->dev.bus_id);
352 privptr->p_env->p_priv = privptr;
353 cgdev->cdev[0]->handler = claw_irq_handler;
354 cgdev->cdev[1]->handler = claw_irq_handler;
355 cgdev->dev.driver_data = privptr;
356 #ifdef FUNCTRACE
357 printk(KERN_INFO "claw:%s exit on line %d, "
358 "rc = 0\n",__FUNCTION__,__LINE__);
359 #endif
360 CLAW_DBF_TEXT(2,setup,"prbext 0");
361
362 return 0;
363 } /* end of claw_probe */
364
365 /*-------------------------------------------------------------------*
366 * claw_tx *
367 *-------------------------------------------------------------------*/
368
369 static int
370 claw_tx(struct sk_buff *skb, struct net_device *dev)
371 {
372 int rc;
373 struct claw_privbk *privptr=dev->priv;
374 unsigned long saveflags;
375 struct chbk *p_ch;
376
377 #ifdef FUNCTRACE
378 printk(KERN_INFO "%s:%s enter\n",dev->name,__FUNCTION__);
379 #endif
380 CLAW_DBF_TEXT(4,trace,"claw_tx");
381 p_ch=&privptr->channel[WRITE];
382 if (skb == NULL) {
383 printk(KERN_WARNING "%s: null pointer passed as sk_buffer\n",
384 dev->name);
385 privptr->stats.tx_dropped++;
386 #ifdef FUNCTRACE
387 printk(KERN_INFO "%s: %s() exit on line %d, rc = EIO\n",
388 dev->name,__FUNCTION__, __LINE__);
389 #endif
390 CLAW_DBF_TEXT_(2,trace,"clawtx%d",-EIO);
391 return -EIO;
392 }
393
394 #ifdef IOTRACE
395 printk(KERN_INFO "%s: variable sk_buff=\n",dev->name);
396 dumpit((char *) skb, sizeof(struct sk_buff));
397 printk(KERN_INFO "%s: variable dev=\n",dev->name);
398 dumpit((char *) dev, sizeof(struct net_device));
399 #endif
400 spin_lock_irqsave(get_ccwdev_lock(p_ch->cdev), saveflags);
401 rc=claw_hw_tx( skb, dev, 1 );
402 spin_unlock_irqrestore(get_ccwdev_lock(p_ch->cdev), saveflags);
403 #ifdef FUNCTRACE
404 printk(KERN_INFO "%s:%s exit on line %d, rc = %d\n",
405 dev->name, __FUNCTION__, __LINE__, rc);
406 #endif
407 CLAW_DBF_TEXT_(4,trace,"clawtx%d",rc);
408 return rc;
409 } /* end of claw_tx */
410
411 /*------------------------------------------------------------------*
412 * pack the collect queue into an skb and return it *
413 * If not packing just return the top skb from the queue *
414 *------------------------------------------------------------------*/
415
416 static struct sk_buff *
417 claw_pack_skb(struct claw_privbk *privptr)
418 {
419 struct sk_buff *new_skb,*held_skb;
420 struct chbk *p_ch = &privptr->channel[WRITE];
421 struct claw_env *p_env = privptr->p_env;
422 int pkt_cnt,pk_ind,so_far;
423
424 new_skb = NULL; /* assume no dice */
425 pkt_cnt = 0;
426 CLAW_DBF_TEXT(4,trace,"PackSKBe");
427 if (!skb_queue_empty(&p_ch->collect_queue)) {
428 /* some data */
429 held_skb = skb_dequeue(&p_ch->collect_queue);
430 if (held_skb)
431 dev_kfree_skb_any(held_skb);
432 else
433 return NULL;
434 if (p_env->packing != DO_PACKED)
435 return held_skb;
436 /* get a new SKB we will pack at least one */
437 new_skb = dev_alloc_skb(p_env->write_size);
438 if (new_skb == NULL) {
439 atomic_inc(&held_skb->users);
440 skb_queue_head(&p_ch->collect_queue,held_skb);
441 return NULL;
442 }
443 /* we have packed packet and a place to put it */
444 pk_ind = 1;
445 so_far = 0;
446 new_skb->cb[1] = 'P'; /* every skb on queue has pack header */
447 while ((pk_ind) && (held_skb != NULL)) {
448 if (held_skb->len+so_far <= p_env->write_size-8) {
449 memcpy(skb_put(new_skb,held_skb->len),
450 held_skb->data,held_skb->len);
451 privptr->stats.tx_packets++;
452 so_far += held_skb->len;
453 pkt_cnt++;
454 dev_kfree_skb_any(held_skb);
455 held_skb = skb_dequeue(&p_ch->collect_queue);
456 if (held_skb)
457 atomic_dec(&held_skb->users);
458 } else {
459 pk_ind = 0;
460 atomic_inc(&held_skb->users);
461 skb_queue_head(&p_ch->collect_queue,held_skb);
462 }
463 }
464 #ifdef IOTRACE
465 printk(KERN_INFO "%s: %s() Packed %d len %d\n",
466 p_env->ndev->name,
467 __FUNCTION__,pkt_cnt,new_skb->len);
468 #endif
469 }
470 CLAW_DBF_TEXT(4,trace,"PackSKBx");
471 return new_skb;
472 }
473
474 /*-------------------------------------------------------------------*
475 * claw_change_mtu *
476 * *
477 *-------------------------------------------------------------------*/
478
479 static int
480 claw_change_mtu(struct net_device *dev, int new_mtu)
481 {
482 struct claw_privbk *privptr=dev->priv;
483 int buff_size;
484 #ifdef FUNCTRACE
485 printk(KERN_INFO "%s:%s Enter \n",dev->name,__FUNCTION__);
486 #endif
487 #ifdef DEBUGMSG
488 printk(KERN_INFO "variable dev =\n");
489 dumpit((char *) dev, sizeof(struct net_device));
490 printk(KERN_INFO "variable new_mtu = %d\n", new_mtu);
491 #endif
492 CLAW_DBF_TEXT(4,trace,"setmtu");
493 buff_size = privptr->p_env->write_size;
494 if ((new_mtu < 60) || (new_mtu > buff_size)) {
495 #ifdef FUNCTRACE
496 printk(KERN_INFO "%s:%s Exit on line %d, rc=EINVAL\n",
497 dev->name,
498 __FUNCTION__, __LINE__);
499 #endif
500 return -EINVAL;
501 }
502 dev->mtu = new_mtu;
503 #ifdef FUNCTRACE
504 printk(KERN_INFO "%s:%s Exit on line %d\n",dev->name,
505 __FUNCTION__, __LINE__);
506 #endif
507 return 0;
508 } /* end of claw_change_mtu */
509
510
511 /*-------------------------------------------------------------------*
512 * claw_open *
513 * *
514 *-------------------------------------------------------------------*/
515 static int
516 claw_open(struct net_device *dev)
517 {
518
519 int rc;
520 int i;
521 unsigned long saveflags=0;
522 unsigned long parm;
523 struct claw_privbk *privptr;
524 DECLARE_WAITQUEUE(wait, current);
525 struct timer_list timer;
526 struct ccwbk *p_buf;
527
528 #ifdef FUNCTRACE
529 printk(KERN_INFO "%s:%s Enter \n",dev->name,__FUNCTION__);
530 #endif
531 CLAW_DBF_TEXT(4,trace,"open");
532 if (!dev || (dev->name[0] == 0x00)) {
533 CLAW_DBF_TEXT(2,trace,"BadDev");
534 printk(KERN_WARNING "claw: Bad device at open failing \n");
535 return -ENODEV;
536 }
537 privptr = (struct claw_privbk *)dev->priv;
538 /* allocate and initialize CCW blocks */
539 if (privptr->buffs_alloc == 0) {
540 rc=init_ccw_bk(dev);
541 if (rc) {
542 printk(KERN_INFO "%s:%s Exit on line %d, rc=ENOMEM\n",
543 dev->name,
544 __FUNCTION__, __LINE__);
545 CLAW_DBF_TEXT(2,trace,"openmem");
546 return -ENOMEM;
547 }
548 }
549 privptr->system_validate_comp=0;
550 privptr->release_pend=0;
551 if(strncmp(privptr->p_env->api_type,WS_APPL_NAME_PACKED,6) == 0) {
552 privptr->p_env->read_size=DEF_PACK_BUFSIZE;
553 privptr->p_env->write_size=DEF_PACK_BUFSIZE;
554 privptr->p_env->packing=PACKING_ASK;
555 } else {
556 privptr->p_env->packing=0;
557 privptr->p_env->read_size=CLAW_FRAME_SIZE;
558 privptr->p_env->write_size=CLAW_FRAME_SIZE;
559 }
560 claw_set_busy(dev);
561 tasklet_init(&privptr->channel[READ].tasklet, claw_irq_tasklet,
562 (unsigned long) &privptr->channel[READ]);
563 for ( i = 0; i < 2; i++) {
564 CLAW_DBF_TEXT_(2,trace,"opn_ch%d",i);
565 init_waitqueue_head(&privptr->channel[i].wait);
566 /* skb_queue_head_init(&p_ch->io_queue); */
567 if (i == WRITE)
568 skb_queue_head_init(
569 &privptr->channel[WRITE].collect_queue);
570 privptr->channel[i].flag_a = 0;
571 privptr->channel[i].IO_active = 0;
572 privptr->channel[i].flag &= ~CLAW_TIMER;
573 init_timer(&timer);
574 timer.function = (void *)claw_timer;
575 timer.data = (unsigned long)(&privptr->channel[i]);
576 timer.expires = jiffies + 15*HZ;
577 add_timer(&timer);
578 spin_lock_irqsave(get_ccwdev_lock(
579 privptr->channel[i].cdev), saveflags);
580 parm = (unsigned long) &privptr->channel[i];
581 privptr->channel[i].claw_state = CLAW_START_HALT_IO;
582 rc = 0;
583 add_wait_queue(&privptr->channel[i].wait, &wait);
584 rc = ccw_device_halt(
585 (struct ccw_device *)privptr->channel[i].cdev,parm);
586 set_current_state(TASK_INTERRUPTIBLE);
587 spin_unlock_irqrestore(
588 get_ccwdev_lock(privptr->channel[i].cdev), saveflags);
589 schedule();
590 set_current_state(TASK_RUNNING);
591 remove_wait_queue(&privptr->channel[i].wait, &wait);
592 if(rc != 0)
593 ccw_check_return_code(privptr->channel[i].cdev, rc);
594 if((privptr->channel[i].flag & CLAW_TIMER) == 0x00)
595 del_timer(&timer);
596 }
597 if ((((privptr->channel[READ].last_dstat |
598 privptr->channel[WRITE].last_dstat) &
599 ~(DEV_STAT_CHN_END | DEV_STAT_DEV_END)) != 0x00) ||
600 (((privptr->channel[READ].flag |
601 privptr->channel[WRITE].flag) & CLAW_TIMER) != 0x00)) {
602 #ifdef DEBUGMSG
603 printk(KERN_INFO "%s: channel problems during open - read:"
604 " %02x - write: %02x\n",
605 dev->name,
606 privptr->channel[READ].last_dstat,
607 privptr->channel[WRITE].last_dstat);
608 #endif
609 printk(KERN_INFO "%s: remote side is not ready\n", dev->name);
610 CLAW_DBF_TEXT(2,trace,"notrdy");
611
612 for ( i = 0; i < 2; i++) {
613 spin_lock_irqsave(
614 get_ccwdev_lock(privptr->channel[i].cdev),
615 saveflags);
616 parm = (unsigned long) &privptr->channel[i];
617 privptr->channel[i].claw_state = CLAW_STOP;
618 rc = ccw_device_halt(
619 (struct ccw_device *)&privptr->channel[i].cdev,
620 parm);
621 spin_unlock_irqrestore(
622 get_ccwdev_lock(privptr->channel[i].cdev),
623 saveflags);
624 if (rc != 0) {
625 ccw_check_return_code(
626 privptr->channel[i].cdev, rc);
627 }
628 }
629 free_pages((unsigned long)privptr->p_buff_ccw,
630 (int)pages_to_order_of_mag(privptr->p_buff_ccw_num));
631 if (privptr->p_env->read_size < PAGE_SIZE) {
632 free_pages((unsigned long)privptr->p_buff_read,
633 (int)pages_to_order_of_mag(
634 privptr->p_buff_read_num));
635 }
636 else {
637 p_buf=privptr->p_read_active_first;
638 while (p_buf!=NULL) {
639 free_pages((unsigned long)p_buf->p_buffer,
640 (int)pages_to_order_of_mag(
641 privptr->p_buff_pages_perread ));
642 p_buf=p_buf->next;
643 }
644 }
645 if (privptr->p_env->write_size < PAGE_SIZE ) {
646 free_pages((unsigned long)privptr->p_buff_write,
647 (int)pages_to_order_of_mag(
648 privptr->p_buff_write_num));
649 }
650 else {
651 p_buf=privptr->p_write_active_first;
652 while (p_buf!=NULL) {
653 free_pages((unsigned long)p_buf->p_buffer,
654 (int)pages_to_order_of_mag(
655 privptr->p_buff_pages_perwrite ));
656 p_buf=p_buf->next;
657 }
658 }
659 privptr->buffs_alloc = 0;
660 privptr->channel[READ].flag= 0x00;
661 privptr->channel[WRITE].flag = 0x00;
662 privptr->p_buff_ccw=NULL;
663 privptr->p_buff_read=NULL;
664 privptr->p_buff_write=NULL;
665 claw_clear_busy(dev);
666 #ifdef FUNCTRACE
667 printk(KERN_INFO "%s:%s Exit on line %d, rc=EIO\n",
668 dev->name,__FUNCTION__,__LINE__);
669 #endif
670 CLAW_DBF_TEXT(2,trace,"open EIO");
671 return -EIO;
672 }
673
674 /* Send SystemValidate command */
675
676 claw_clear_busy(dev);
677
678 #ifdef FUNCTRACE
679 printk(KERN_INFO "%s:%s Exit on line %d, rc=0\n",
680 dev->name,__FUNCTION__,__LINE__);
681 #endif
682 CLAW_DBF_TEXT(4,trace,"openok");
683 return 0;
684 } /* end of claw_open */
685
686 /*-------------------------------------------------------------------*
687 * *
688 * claw_irq_handler *
689 * *
690 *--------------------------------------------------------------------*/
691 static void
692 claw_irq_handler(struct ccw_device *cdev,
693 unsigned long intparm, struct irb *irb)
694 {
695 struct chbk *p_ch = NULL;
696 struct claw_privbk *privptr = NULL;
697 struct net_device *dev = NULL;
698 struct claw_env *p_env;
699 struct chbk *p_ch_r=NULL;
700
701
702 #ifdef FUNCTRACE
703 printk(KERN_INFO "%s enter \n",__FUNCTION__);
704 #endif
705 CLAW_DBF_TEXT(4,trace,"clawirq");
706 /* Bypass all 'unsolicited interrupts' */
707 if (!cdev->dev.driver_data) {
708 printk(KERN_WARNING "claw: unsolicited interrupt for device:"
709 "%s received c-%02x d-%02x\n",
710 cdev->dev.bus_id,irb->scsw.cstat, irb->scsw.dstat);
711 #ifdef FUNCTRACE
712 printk(KERN_INFO "claw: %s() "
713 "exit on line %d\n",__FUNCTION__,__LINE__);
714 #endif
715 CLAW_DBF_TEXT(2,trace,"badirq");
716 return;
717 }
718 privptr = (struct claw_privbk *)cdev->dev.driver_data;
719
720 /* Try to extract channel from driver data. */
721 if (privptr->channel[READ].cdev == cdev)
722 p_ch = &privptr->channel[READ];
723 else if (privptr->channel[WRITE].cdev == cdev)
724 p_ch = &privptr->channel[WRITE];
725 else {
726 printk(KERN_WARNING "claw: Can't determine channel for "
727 "interrupt, device %s\n", cdev->dev.bus_id);
728 CLAW_DBF_TEXT(2,trace,"badchan");
729 return;
730 }
731 CLAW_DBF_TEXT_(4,trace,"IRQCH=%d",p_ch->flag);
732
733 dev = (struct net_device *) (p_ch->ndev);
734 p_env=privptr->p_env;
735
736 #ifdef IOTRACE
737 printk(KERN_INFO "%s: interrupt for device: %04x "
738 "received c-%02x d-%02x state-%02x\n",
739 dev->name, p_ch->devno, irb->scsw.cstat,
740 irb->scsw.dstat, p_ch->claw_state);
741 #endif
742
743 /* Copy interruption response block. */
744 memcpy(p_ch->irb, irb, sizeof(struct irb));
745
746 /* Check for good subchannel return code, otherwise error message */
747 if (irb->scsw.cstat && !(irb->scsw.cstat & SCHN_STAT_PCI)) {
748 printk(KERN_INFO "%s: subchannel check for device: %04x -"
749 " Sch Stat %02x Dev Stat %02x CPA - %04x\n",
750 dev->name, p_ch->devno,
751 irb->scsw.cstat, irb->scsw.dstat,irb->scsw.cpa);
752 #ifdef IOTRACE
753 dumpit((char *)irb,sizeof(struct irb));
754 dumpit((char *)(unsigned long)irb->scsw.cpa,
755 sizeof(struct ccw1));
756 #endif
757 #ifdef FUNCTRACE
758 printk(KERN_INFO "%s:%s Exit on line %d\n",
759 dev->name,__FUNCTION__,__LINE__);
760 #endif
761 CLAW_DBF_TEXT(2,trace,"chanchk");
762 /* return; */
763 }
764
765 /* Check the reason-code of a unit check */
766 if (irb->scsw.dstat & DEV_STAT_UNIT_CHECK) {
767 ccw_check_unit_check(p_ch, irb->ecw[0]);
768 }
769
770 /* State machine to bring the connection up, down and to restart */
771 p_ch->last_dstat = irb->scsw.dstat;
772
773 switch (p_ch->claw_state) {
774 case CLAW_STOP:/* HALT_IO by claw_release (halt sequence) */
775 #ifdef DEBUGMSG
776 printk(KERN_INFO "%s: CLAW_STOP enter\n", dev->name);
777 #endif
778 if (!((p_ch->irb->scsw.stctl & SCSW_STCTL_SEC_STATUS) ||
779 (p_ch->irb->scsw.stctl == SCSW_STCTL_STATUS_PEND) ||
780 (p_ch->irb->scsw.stctl ==
781 (SCSW_STCTL_ALERT_STATUS | SCSW_STCTL_STATUS_PEND)))) {
782 #ifdef FUNCTRACE
783 printk(KERN_INFO "%s:%s Exit on line %d\n",
784 dev->name,__FUNCTION__,__LINE__);
785 #endif
786 return;
787 }
788 wake_up(&p_ch->wait); /* wake up claw_release */
789
790 #ifdef DEBUGMSG
791 printk(KERN_INFO "%s: CLAW_STOP exit\n", dev->name);
792 #endif
793 #ifdef FUNCTRACE
794 printk(KERN_INFO "%s:%s Exit on line %d\n",
795 dev->name,__FUNCTION__,__LINE__);
796 #endif
797 CLAW_DBF_TEXT(4,trace,"stop");
798 return;
799
800 case CLAW_START_HALT_IO: /* HALT_IO issued by claw_open */
801 #ifdef DEBUGMSG
802 printk(KERN_INFO "%s: process CLAW_STAT_HALT_IO\n",
803 dev->name);
804 #endif
805 if (!((p_ch->irb->scsw.stctl & SCSW_STCTL_SEC_STATUS) ||
806 (p_ch->irb->scsw.stctl == SCSW_STCTL_STATUS_PEND) ||
807 (p_ch->irb->scsw.stctl ==
808 (SCSW_STCTL_ALERT_STATUS | SCSW_STCTL_STATUS_PEND)))) {
809 #ifdef FUNCTRACE
810 printk(KERN_INFO "%s:%s Exit on line %d\n",
811 dev->name,__FUNCTION__,__LINE__);
812 #endif
813 CLAW_DBF_TEXT(4,trace,"haltio");
814 return;
815 }
816 if (p_ch->flag == CLAW_READ) {
817 p_ch->claw_state = CLAW_START_READ;
818 wake_up(&p_ch->wait); /* wake claw_open (READ)*/
819 }
820 else
821 if (p_ch->flag == CLAW_WRITE) {
822 p_ch->claw_state = CLAW_START_WRITE;
823 /* send SYSTEM_VALIDATE */
824 claw_strt_read(dev, LOCK_NO);
825 claw_send_control(dev,
826 SYSTEM_VALIDATE_REQUEST,
827 0, 0, 0,
828 p_env->host_name,
829 p_env->adapter_name );
830 } else {
831 printk(KERN_WARNING "claw: unsolicited "
832 "interrupt for device:"
833 "%s received c-%02x d-%02x\n",
834 cdev->dev.bus_id,
835 irb->scsw.cstat,
836 irb->scsw.dstat);
837 return;
838 }
839 #ifdef DEBUGMSG
840 printk(KERN_INFO "%s: process CLAW_STAT_HALT_IO exit\n",
841 dev->name);
842 #endif
843 #ifdef FUNCTRACE
844 printk(KERN_INFO "%s:%s Exit on line %d\n",
845 dev->name,__FUNCTION__,__LINE__);
846 #endif
847 CLAW_DBF_TEXT(4,trace,"haltio");
848 return;
849 case CLAW_START_READ:
850 CLAW_DBF_TEXT(4,trace,"ReadIRQ");
851 if (p_ch->irb->scsw.dstat & DEV_STAT_UNIT_CHECK) {
852 clear_bit(0, (void *)&p_ch->IO_active);
853 if ((p_ch->irb->ecw[0] & 0x41) == 0x41 ||
854 (p_ch->irb->ecw[0] & 0x40) == 0x40 ||
855 (p_ch->irb->ecw[0]) == 0)
856 {
857 privptr->stats.rx_errors++;
858 printk(KERN_INFO "%s: Restart is "
859 "required after remote "
860 "side recovers \n",
861 dev->name);
862 }
863 #ifdef FUNCTRACE
864 printk(KERN_INFO "%s:%s Exit on line %d\n",
865 dev->name,__FUNCTION__,__LINE__);
866 #endif
867 CLAW_DBF_TEXT(4,trace,"notrdy");
868 return;
869 }
870 if ((p_ch->irb->scsw.cstat & SCHN_STAT_PCI) &&
871 (p_ch->irb->scsw.dstat==0)) {
872 if (test_and_set_bit(CLAW_BH_ACTIVE,
873 (void *)&p_ch->flag_a) == 0) {
874 tasklet_schedule(&p_ch->tasklet);
875 }
876 else {
877 CLAW_DBF_TEXT(4,trace,"PCINoBH");
878 }
879 #ifdef FUNCTRACE
880 printk(KERN_INFO "%s:%s Exit on line %d\n",
881 dev->name,__FUNCTION__,__LINE__);
882 #endif
883 CLAW_DBF_TEXT(4,trace,"PCI_read");
884 return;
885 }
886 if(!((p_ch->irb->scsw.stctl & SCSW_STCTL_SEC_STATUS) ||
887 (p_ch->irb->scsw.stctl == SCSW_STCTL_STATUS_PEND) ||
888 (p_ch->irb->scsw.stctl ==
889 (SCSW_STCTL_ALERT_STATUS | SCSW_STCTL_STATUS_PEND)))) {
890 #ifdef FUNCTRACE
891 printk(KERN_INFO "%s:%s Exit on line %d\n",
892 dev->name,__FUNCTION__,__LINE__);
893 #endif
894 CLAW_DBF_TEXT(4,trace,"SPend_rd");
895 return;
896 }
897 clear_bit(0, (void *)&p_ch->IO_active);
898 claw_clearbit_busy(TB_RETRY,dev);
899 if (test_and_set_bit(CLAW_BH_ACTIVE,
900 (void *)&p_ch->flag_a) == 0) {
901 tasklet_schedule(&p_ch->tasklet);
902 }
903 else {
904 CLAW_DBF_TEXT(4,trace,"RdBHAct");
905 }
906
907 #ifdef DEBUGMSG
908 printk(KERN_INFO "%s: process CLAW_START_READ exit\n",
909 dev->name);
910 #endif
911 #ifdef FUNCTRACE
912 printk(KERN_INFO "%s:%s Exit on line %d\n",
913 dev->name,__FUNCTION__,__LINE__);
914 #endif
915 CLAW_DBF_TEXT(4,trace,"RdIRQXit");
916 return;
917 case CLAW_START_WRITE:
918 if (p_ch->irb->scsw.dstat & DEV_STAT_UNIT_CHECK) {
919 printk(KERN_INFO "%s: Unit Check Occured in "
920 "write channel\n",dev->name);
921 clear_bit(0, (void *)&p_ch->IO_active);
922 if (p_ch->irb->ecw[0] & 0x80 ) {
923 printk(KERN_INFO "%s: Resetting Event "
924 "occurred:\n",dev->name);
925 init_timer(&p_ch->timer);
926 p_ch->timer.function =
927 (void *)claw_write_retry;
928 p_ch->timer.data = (unsigned long)p_ch;
929 p_ch->timer.expires = jiffies + 10*HZ;
930 add_timer(&p_ch->timer);
931 printk(KERN_INFO "%s: write connection "
932 "restarting\n",dev->name);
933 }
934 #ifdef FUNCTRACE
935 printk(KERN_INFO "%s:%s Exit on line %d\n",
936 dev->name,__FUNCTION__,__LINE__);
937 #endif
938 CLAW_DBF_TEXT(4,trace,"rstrtwrt");
939 return;
940 }
941 if (p_ch->irb->scsw.dstat & DEV_STAT_UNIT_EXCEP) {
942 clear_bit(0, (void *)&p_ch->IO_active);
943 printk(KERN_INFO "%s: Unit Exception "
944 "Occured in write channel\n",
945 dev->name);
946 }
947 if(!((p_ch->irb->scsw.stctl & SCSW_STCTL_SEC_STATUS) ||
948 (p_ch->irb->scsw.stctl == SCSW_STCTL_STATUS_PEND) ||
949 (p_ch->irb->scsw.stctl ==
950 (SCSW_STCTL_ALERT_STATUS | SCSW_STCTL_STATUS_PEND)))) {
951 #ifdef FUNCTRACE
952 printk(KERN_INFO "%s:%s Exit on line %d\n",
953 dev->name,__FUNCTION__,__LINE__);
954 #endif
955 CLAW_DBF_TEXT(4,trace,"writeUE");
956 return;
957 }
958 clear_bit(0, (void *)&p_ch->IO_active);
959 if (claw_test_and_setbit_busy(TB_TX,dev)==0) {
960 claw_write_next(p_ch);
961 claw_clearbit_busy(TB_TX,dev);
962 claw_clear_busy(dev);
963 }
964 p_ch_r=(struct chbk *)&privptr->channel[READ];
965 if (test_and_set_bit(CLAW_BH_ACTIVE,
966 (void *)&p_ch_r->flag_a) == 0) {
967 tasklet_schedule(&p_ch_r->tasklet);
968 }
969
970 #ifdef DEBUGMSG
971 printk(KERN_INFO "%s: process CLAW_START_WRITE exit\n",
972 dev->name);
973 #endif
974 #ifdef FUNCTRACE
975 printk(KERN_INFO "%s:%s Exit on line %d\n",
976 dev->name,__FUNCTION__,__LINE__);
977 #endif
978 CLAW_DBF_TEXT(4,trace,"StWtExit");
979 return;
980 default:
981 printk(KERN_WARNING "%s: wrong selection code - irq "
982 "state=%d\n",dev->name,p_ch->claw_state);
983 #ifdef FUNCTRACE
984 printk(KERN_INFO "%s:%s Exit on line %d\n",
985 dev->name,__FUNCTION__,__LINE__);
986 #endif
987 CLAW_DBF_TEXT(2,trace,"badIRQ");
988 return;
989 }
990
991 } /* end of claw_irq_handler */
992
993
994 /*-------------------------------------------------------------------*
995 * claw_irq_tasklet *
996 * *
997 *--------------------------------------------------------------------*/
998 static void
999 claw_irq_tasklet ( unsigned long data )
1000 {
1001 struct chbk * p_ch;
1002 struct net_device *dev;
1003 struct claw_privbk * privptr;
1004
1005 p_ch = (struct chbk *) data;
1006 dev = (struct net_device *)p_ch->ndev;
1007 #ifdef FUNCTRACE
1008 printk(KERN_INFO "%s:%s Enter \n",dev->name,__FUNCTION__);
1009 #endif
1010 #ifdef DEBUGMSG
1011 printk(KERN_INFO "%s: variable p_ch =\n",dev->name);
1012 dumpit((char *) p_ch, sizeof(struct chbk));
1013 #endif
1014 CLAW_DBF_TEXT(4,trace,"IRQtask");
1015
1016 privptr = (struct claw_privbk *) dev->priv;
1017
1018 #ifdef DEBUGMSG
1019 printk(KERN_INFO "%s: bh routine - state-%02x\n" ,
1020 dev->name, p_ch->claw_state);
1021 #endif
1022
1023 unpack_read(dev);
1024 clear_bit(CLAW_BH_ACTIVE, (void *)&p_ch->flag_a);
1025 CLAW_DBF_TEXT(4,trace,"TskletXt");
1026 #ifdef FUNCTRACE
1027 printk(KERN_INFO "%s:%s Exit on line %d\n",
1028 dev->name,__FUNCTION__,__LINE__);
1029 #endif
1030 return;
1031 } /* end of claw_irq_bh */
1032
1033 /*-------------------------------------------------------------------*
1034 * claw_release *
1035 * *
1036 *--------------------------------------------------------------------*/
1037 static int
1038 claw_release(struct net_device *dev)
1039 {
1040 int rc;
1041 int i;
1042 unsigned long saveflags;
1043 unsigned long parm;
1044 struct claw_privbk *privptr;
1045 DECLARE_WAITQUEUE(wait, current);
1046 struct ccwbk* p_this_ccw;
1047 struct ccwbk* p_buf;
1048
1049 if (!dev)
1050 return 0;
1051 privptr = (struct claw_privbk *) dev->priv;
1052 if (!privptr)
1053 return 0;
1054 #ifdef FUNCTRACE
1055 printk(KERN_INFO "%s:%s Enter \n",dev->name,__FUNCTION__);
1056 #endif
1057 CLAW_DBF_TEXT(4,trace,"release");
1058 #ifdef DEBUGMSG
1059 printk(KERN_INFO "%s: variable dev =\n",dev->name);
1060 dumpit((char *) dev, sizeof(struct net_device));
1061 printk(KERN_INFO "Priv Buffalloc %d\n",privptr->buffs_alloc);
1062 printk(KERN_INFO "Priv p_buff_ccw = %p\n",&privptr->p_buff_ccw);
1063 #endif
1064 privptr->release_pend=1;
1065 claw_setbit_busy(TB_STOP,dev);
1066 for ( i = 1; i >=0 ; i--) {
1067 spin_lock_irqsave(
1068 get_ccwdev_lock(privptr->channel[i].cdev), saveflags);
1069 /* del_timer(&privptr->channel[READ].timer); */
1070 privptr->channel[i].claw_state = CLAW_STOP;
1071 privptr->channel[i].IO_active = 0;
1072 parm = (unsigned long) &privptr->channel[i];
1073 if (i == WRITE)
1074 claw_purge_skb_queue(
1075 &privptr->channel[WRITE].collect_queue);
1076 rc = ccw_device_halt (privptr->channel[i].cdev, parm);
1077 if (privptr->system_validate_comp==0x00) /* never opened? */
1078 init_waitqueue_head(&privptr->channel[i].wait);
1079 add_wait_queue(&privptr->channel[i].wait, &wait);
1080 set_current_state(TASK_INTERRUPTIBLE);
1081 spin_unlock_irqrestore(
1082 get_ccwdev_lock(privptr->channel[i].cdev), saveflags);
1083 schedule();
1084 set_current_state(TASK_RUNNING);
1085 remove_wait_queue(&privptr->channel[i].wait, &wait);
1086 if (rc != 0) {
1087 ccw_check_return_code(privptr->channel[i].cdev, rc);
1088 }
1089 }
1090 if (privptr->pk_skb != NULL) {
1091 dev_kfree_skb_any(privptr->pk_skb);
1092 privptr->pk_skb = NULL;
1093 }
1094 if(privptr->buffs_alloc != 1) {
1095 #ifdef FUNCTRACE
1096 printk(KERN_INFO "%s:%s Exit on line %d\n",
1097 dev->name,__FUNCTION__,__LINE__);
1098 #endif
1099 CLAW_DBF_TEXT(4,trace,"none2fre");
1100 return 0;
1101 }
1102 CLAW_DBF_TEXT(4,trace,"freebufs");
1103 if (privptr->p_buff_ccw != NULL) {
1104 free_pages((unsigned long)privptr->p_buff_ccw,
1105 (int)pages_to_order_of_mag(privptr->p_buff_ccw_num));
1106 }
1107 CLAW_DBF_TEXT(4,trace,"freeread");
1108 if (privptr->p_env->read_size < PAGE_SIZE) {
1109 if (privptr->p_buff_read != NULL) {
1110 free_pages((unsigned long)privptr->p_buff_read,
1111 (int)pages_to_order_of_mag(privptr->p_buff_read_num));
1112 }
1113 }
1114 else {
1115 p_buf=privptr->p_read_active_first;
1116 while (p_buf!=NULL) {
1117 free_pages((unsigned long)p_buf->p_buffer,
1118 (int)pages_to_order_of_mag(
1119 privptr->p_buff_pages_perread ));
1120 p_buf=p_buf->next;
1121 }
1122 }
1123 CLAW_DBF_TEXT(4,trace,"freewrit");
1124 if (privptr->p_env->write_size < PAGE_SIZE ) {
1125 free_pages((unsigned long)privptr->p_buff_write,
1126 (int)pages_to_order_of_mag(privptr->p_buff_write_num));
1127 }
1128 else {
1129 p_buf=privptr->p_write_active_first;
1130 while (p_buf!=NULL) {
1131 free_pages((unsigned long)p_buf->p_buffer,
1132 (int)pages_to_order_of_mag(
1133 privptr->p_buff_pages_perwrite ));
1134 p_buf=p_buf->next;
1135 }
1136 }
1137 CLAW_DBF_TEXT(4,trace,"clearptr");
1138 privptr->buffs_alloc = 0;
1139 privptr->p_buff_ccw=NULL;
1140 privptr->p_buff_read=NULL;
1141 privptr->p_buff_write=NULL;
1142 privptr->system_validate_comp=0;
1143 privptr->release_pend=0;
1144 /* Remove any writes that were pending and reset all reads */
1145 p_this_ccw=privptr->p_read_active_first;
1146 while (p_this_ccw!=NULL) {
1147 p_this_ccw->header.length=0xffff;
1148 p_this_ccw->header.opcode=0xff;
1149 p_this_ccw->header.flag=0x00;
1150 p_this_ccw=p_this_ccw->next;
1151 }
1152
1153 while (privptr->p_write_active_first!=NULL) {
1154 p_this_ccw=privptr->p_write_active_first;
1155 p_this_ccw->header.flag=CLAW_PENDING;
1156 privptr->p_write_active_first=p_this_ccw->next;
1157 p_this_ccw->next=privptr->p_write_free_chain;
1158 privptr->p_write_free_chain=p_this_ccw;
1159 ++privptr->write_free_count;
1160 }
1161 privptr->p_write_active_last=NULL;
1162 privptr->mtc_logical_link = -1;
1163 privptr->mtc_skipping = 1;
1164 privptr->mtc_offset=0;
1165
1166 if (((privptr->channel[READ].last_dstat |
1167 privptr->channel[WRITE].last_dstat) &
1168 ~(DEV_STAT_CHN_END | DEV_STAT_DEV_END)) != 0x00) {
1169 printk(KERN_WARNING "%s: channel problems during close - "
1170 "read: %02x - write: %02x\n",
1171 dev->name,
1172 privptr->channel[READ].last_dstat,
1173 privptr->channel[WRITE].last_dstat);
1174 CLAW_DBF_TEXT(2,trace,"badclose");
1175 }
1176 #ifdef FUNCTRACE
1177 printk(KERN_INFO "%s:%s Exit on line %d\n",
1178 dev->name,__FUNCTION__,__LINE__);
1179 #endif
1180 CLAW_DBF_TEXT(4,trace,"rlsexit");
1181 return 0;
1182 } /* end of claw_release */
1183
1184
1185
1186 /*-------------------------------------------------------------------*
1187 * claw_write_retry *
1188 * *
1189 *--------------------------------------------------------------------*/
1190
1191 static void
1192 claw_write_retry ( struct chbk *p_ch )
1193 {
1194
1195 struct net_device *dev=p_ch->ndev;
1196
1197
1198 #ifdef FUNCTRACE
1199 printk(KERN_INFO "%s:%s Enter\n",dev->name,__FUNCTION__);
1200 printk(KERN_INFO "claw: variable p_ch =\n");
1201 dumpit((char *) p_ch, sizeof(struct chbk));
1202 #endif
1203 CLAW_DBF_TEXT(4,trace,"w_retry");
1204 if (p_ch->claw_state == CLAW_STOP) {
1205 #ifdef FUNCTRACE
1206 printk(KERN_INFO "%s:%s Exit on line %d\n",
1207 dev->name,__FUNCTION__,__LINE__);
1208 #endif
1209 return;
1210 }
1211 #ifdef DEBUGMSG
1212 printk( KERN_INFO "%s:%s state-%02x\n" ,
1213 dev->name,
1214 __FUNCTION__,
1215 p_ch->claw_state);
1216 #endif
1217 claw_strt_out_IO( dev );
1218 #ifdef FUNCTRACE
1219 printk(KERN_INFO "%s:%s Exit on line %d\n",
1220 dev->name,__FUNCTION__,__LINE__);
1221 #endif
1222 CLAW_DBF_TEXT(4,trace,"rtry_xit");
1223 return;
1224 } /* end of claw_write_retry */
1225
1226
1227 /*-------------------------------------------------------------------*
1228 * claw_write_next *
1229 * *
1230 *--------------------------------------------------------------------*/
1231
1232 static void
1233 claw_write_next ( struct chbk * p_ch )
1234 {
1235
1236 struct net_device *dev;
1237 struct claw_privbk *privptr=NULL;
1238 struct sk_buff *pk_skb;
1239 int rc;
1240
1241 #ifdef FUNCTRACE
1242 printk(KERN_INFO "%s:%s Enter \n",p_ch->ndev->name,__FUNCTION__);
1243 printk(KERN_INFO "%s: variable p_ch =\n",p_ch->ndev->name);
1244 dumpit((char *) p_ch, sizeof(struct chbk));
1245 #endif
1246 CLAW_DBF_TEXT(4,trace,"claw_wrt");
1247 if (p_ch->claw_state == CLAW_STOP)
1248 return;
1249 dev = (struct net_device *) p_ch->ndev;
1250 privptr = (struct claw_privbk *) dev->priv;
1251 claw_free_wrt_buf( dev );
1252 if ((privptr->write_free_count > 0) &&
1253 !skb_queue_empty(&p_ch->collect_queue)) {
1254 pk_skb = claw_pack_skb(privptr);
1255 while (pk_skb != NULL) {
1256 rc = claw_hw_tx( pk_skb, dev,1);
1257 if (privptr->write_free_count > 0) {
1258 pk_skb = claw_pack_skb(privptr);
1259 } else
1260 pk_skb = NULL;
1261 }
1262 }
1263 if (privptr->p_write_active_first!=NULL) {
1264 claw_strt_out_IO(dev);
1265 }
1266
1267 #ifdef FUNCTRACE
1268 printk(KERN_INFO "%s:%s Exit on line %d\n",
1269 dev->name,__FUNCTION__,__LINE__);
1270 #endif
1271 return;
1272 } /* end of claw_write_next */
1273
1274 /*-------------------------------------------------------------------*
1275 * *
1276 * claw_timer *
1277 *--------------------------------------------------------------------*/
1278
1279 static void
1280 claw_timer ( struct chbk * p_ch )
1281 {
1282 #ifdef FUNCTRACE
1283 printk(KERN_INFO "%s:%s Entry\n",p_ch->ndev->name,__FUNCTION__);
1284 printk(KERN_INFO "%s: variable p_ch =\n",p_ch->ndev->name);
1285 dumpit((char *) p_ch, sizeof(struct chbk));
1286 #endif
1287 CLAW_DBF_TEXT(4,trace,"timer");
1288 p_ch->flag |= CLAW_TIMER;
1289 wake_up(&p_ch->wait);
1290 #ifdef FUNCTRACE
1291 printk(KERN_INFO "%s:%s Exit on line %d\n",
1292 p_ch->ndev->name,__FUNCTION__,__LINE__);
1293 #endif
1294 return;
1295 } /* end of claw_timer */
1296
1297
1298 /*
1299 *
1300 * functions
1301 */
1302
1303
1304 /*-------------------------------------------------------------------*
1305 * *
1306 * pages_to_order_of_mag *
1307 * *
1308 * takes a number of pages from 1 to 512 and returns the *
1309 * log(num_pages)/log(2) get_free_pages() needs a base 2 order *
1310 * of magnitude get_free_pages() has an upper order of 9 *
1311 *--------------------------------------------------------------------*/
1312
1313 static int inline
1314 pages_to_order_of_mag(int num_of_pages)
1315 {
1316 int order_of_mag=1; /* assume 2 pages */
1317 int nump=2;
1318 #ifdef FUNCTRACE
1319 printk(KERN_INFO "%s Enter pages = %d \n",__FUNCTION__,num_of_pages);
1320 #endif
1321 CLAW_DBF_TEXT_(5,trace,"pages%d",num_of_pages);
1322 if (num_of_pages == 1) {return 0; } /* magnitude of 0 = 1 page */
1323 /* 512 pages = 2Meg on 4k page systems */
1324 if (num_of_pages >= 512) {return 9; }
1325 /* we have two or more pages order is at least 1 */
1326 for (nump=2 ;nump <= 512;nump*=2) {
1327 if (num_of_pages <= nump)
1328 break;
1329 order_of_mag +=1;
1330 }
1331 if (order_of_mag > 9) { order_of_mag = 9; } /* I know it's paranoid */
1332 #ifdef FUNCTRACE
1333 printk(KERN_INFO "%s Exit on line %d, order = %d\n",
1334 __FUNCTION__,__LINE__, order_of_mag);
1335 #endif
1336 CLAW_DBF_TEXT_(5,trace,"mag%d",order_of_mag);
1337 return order_of_mag;
1338 }
1339
1340 /*-------------------------------------------------------------------*
1341 * *
1342 * add_claw_reads *
1343 * *
1344 *--------------------------------------------------------------------*/
1345 static int
1346 add_claw_reads(struct net_device *dev, struct ccwbk* p_first,
1347 struct ccwbk* p_last)
1348 {
1349 struct claw_privbk *privptr;
1350 struct ccw1 temp_ccw;
1351 struct endccw * p_end;
1352 #ifdef IOTRACE
1353 struct ccwbk* p_buf;
1354 #endif
1355 #ifdef FUNCTRACE
1356 printk(KERN_INFO "%s:%s Enter \n",dev->name,__FUNCTION__);
1357 #endif
1358 #ifdef DEBUGMSG
1359 printk(KERN_INFO "dev\n");
1360 dumpit((char *) dev, sizeof(struct net_device));
1361 printk(KERN_INFO "p_first\n");
1362 dumpit((char *) p_first, sizeof(struct ccwbk));
1363 printk(KERN_INFO "p_last\n");
1364 dumpit((char *) p_last, sizeof(struct ccwbk));
1365 #endif
1366 CLAW_DBF_TEXT(4,trace,"addreads");
1367 privptr = dev->priv;
1368 p_end = privptr->p_end_ccw;
1369
1370 /* first CCW and last CCW contains a new set of read channel programs
1371 * to apend the running channel programs
1372 */
1373 if ( p_first==NULL) {
1374 #ifdef FUNCTRACE
1375 printk(KERN_INFO "%s:%s Exit on line %d\n",
1376 dev->name,__FUNCTION__,__LINE__);
1377 #endif
1378 CLAW_DBF_TEXT(4,trace,"addexit");
1379 return 0;
1380 }
1381
1382 /* set up ending CCW sequence for this segment */
1383 if (p_end->read1) {
1384 p_end->read1=0x00; /* second ending CCW is now active */
1385 /* reset ending CCWs and setup TIC CCWs */
1386 p_end->read2_nop2.cmd_code = CCW_CLAW_CMD_READFF;
1387 p_end->read2_nop2.flags = CCW_FLAG_SLI | CCW_FLAG_SKIP;
1388 p_last->r_TIC_1.cda =(__u32)__pa(&p_end->read2_nop1);
1389 p_last->r_TIC_2.cda =(__u32)__pa(&p_end->read2_nop1);
1390 p_end->read2_nop2.cda=0;
1391 p_end->read2_nop2.count=1;
1392 }
1393 else {
1394 p_end->read1=0x01; /* first ending CCW is now active */
1395 /* reset ending CCWs and setup TIC CCWs */
1396 p_end->read1_nop2.cmd_code = CCW_CLAW_CMD_READFF;
1397 p_end->read1_nop2.flags = CCW_FLAG_SLI | CCW_FLAG_SKIP;
1398 p_last->r_TIC_1.cda = (__u32)__pa(&p_end->read1_nop1);
1399 p_last->r_TIC_2.cda = (__u32)__pa(&p_end->read1_nop1);
1400 p_end->read1_nop2.cda=0;
1401 p_end->read1_nop2.count=1;
1402 }
1403
1404 if ( privptr-> p_read_active_first ==NULL ) {
1405 #ifdef DEBUGMSG
1406 printk(KERN_INFO "%s:%s p_read_active_first == NULL \n",
1407 dev->name,__FUNCTION__);
1408 printk(KERN_INFO "%s:%s Read active first/last changed \n",
1409 dev->name,__FUNCTION__);
1410 #endif
1411 privptr-> p_read_active_first= p_first; /* set new first */
1412 privptr-> p_read_active_last = p_last; /* set new last */
1413 }
1414 else {
1415
1416 #ifdef DEBUGMSG
1417 printk(KERN_INFO "%s:%s Read in progress \n",
1418 dev->name,__FUNCTION__);
1419 #endif
1420 /* set up TIC ccw */
1421 temp_ccw.cda= (__u32)__pa(&p_first->read);
1422 temp_ccw.count=0;
1423 temp_ccw.flags=0;
1424 temp_ccw.cmd_code = CCW_CLAW_CMD_TIC;
1425
1426
1427 if (p_end->read1) {
1428
1429 /* first set of CCW's is chained to the new read */
1430 /* chain, so the second set is chained to the active chain. */
1431 /* Therefore modify the second set to point to the new */
1432 /* read chain set up TIC CCWs */
1433 /* make sure we update the CCW so channel doesn't fetch it */
1434 /* when it's only half done */
1435 memcpy( &p_end->read2_nop2, &temp_ccw ,
1436 sizeof(struct ccw1));
1437 privptr->p_read_active_last->r_TIC_1.cda=
1438 (__u32)__pa(&p_first->read);
1439 privptr->p_read_active_last->r_TIC_2.cda=
1440 (__u32)__pa(&p_first->read);
1441 }
1442 else {
1443 /* make sure we update the CCW so channel doesn't */
1444 /* fetch it when it is only half done */
1445 memcpy( &p_end->read1_nop2, &temp_ccw ,
1446 sizeof(struct ccw1));
1447 privptr->p_read_active_last->r_TIC_1.cda=
1448 (__u32)__pa(&p_first->read);
1449 privptr->p_read_active_last->r_TIC_2.cda=
1450 (__u32)__pa(&p_first->read);
1451 }
1452 /* chain in new set of blocks */
1453 privptr->p_read_active_last->next = p_first;
1454 privptr->p_read_active_last=p_last;
1455 } /* end of if ( privptr-> p_read_active_first ==NULL) */
1456 #ifdef IOTRACE
1457 printk(KERN_INFO "%s:%s dump p_last CCW BK \n",dev->name,__FUNCTION__);
1458 dumpit((char *)p_last, sizeof(struct ccwbk));
1459 printk(KERN_INFO "%s:%s dump p_end CCW BK \n",dev->name,__FUNCTION__);
1460 dumpit((char *)p_end, sizeof(struct endccw));
1461
1462 printk(KERN_INFO "%s:%s dump p_first CCW BK \n",dev->name,__FUNCTION__);
1463 dumpit((char *)p_first, sizeof(struct ccwbk));
1464 printk(KERN_INFO "%s:%s Dump Active CCW chain \n",
1465 dev->name,__FUNCTION__);
1466 p_buf=privptr->p_read_active_first;
1467 while (p_buf!=NULL) {
1468 dumpit((char *)p_buf, sizeof(struct ccwbk));
1469 p_buf=p_buf->next;
1470 }
1471 #endif
1472 #ifdef FUNCTRACE
1473 printk(KERN_INFO "%s:%s Exit on line %d\n",
1474 dev->name,__FUNCTION__,__LINE__);
1475 #endif
1476 CLAW_DBF_TEXT(4,trace,"addexit");
1477 return 0;
1478 } /* end of add_claw_reads */
1479
1480 /*-------------------------------------------------------------------*
1481 * ccw_check_return_code *
1482 * *
1483 *-------------------------------------------------------------------*/
1484
1485 static void inline
1486 ccw_check_return_code(struct ccw_device *cdev, int return_code)
1487 {
1488 #ifdef FUNCTRACE
1489 printk(KERN_INFO "%s: %s() > enter \n",
1490 cdev->dev.bus_id,__FUNCTION__);
1491 #endif
1492 CLAW_DBF_TEXT(4,trace,"ccwret");
1493 #ifdef DEBUGMSG
1494 printk(KERN_INFO "variable cdev =\n");
1495 dumpit((char *) cdev, sizeof(struct ccw_device));
1496 printk(KERN_INFO "variable return_code = %d\n",return_code);
1497 #endif
1498 if (return_code != 0) {
1499 switch (return_code) {
1500 case -EBUSY:
1501 printk(KERN_INFO "%s: Busy !\n",
1502 cdev->dev.bus_id);
1503 break;
1504 case -ENODEV:
1505 printk(KERN_EMERG "%s: Missing device called "
1506 "for IO ENODEV\n", cdev->dev.bus_id);
1507 break;
1508 case -EIO:
1509 printk(KERN_EMERG "%s: Status pending... EIO \n",
1510 cdev->dev.bus_id);
1511 break;
1512 case -EINVAL:
1513 printk(KERN_EMERG "%s: Invalid Dev State EINVAL \n",
1514 cdev->dev.bus_id);
1515 break;
1516 default:
1517 printk(KERN_EMERG "%s: Unknown error in "
1518 "Do_IO %d\n",cdev->dev.bus_id, return_code);
1519 }
1520 }
1521 #ifdef FUNCTRACE
1522 printk(KERN_INFO "%s: %s() > exit on line %d\n",
1523 cdev->dev.bus_id,__FUNCTION__,__LINE__);
1524 #endif
1525 CLAW_DBF_TEXT(4,trace,"ccwret");
1526 } /* end of ccw_check_return_code */
1527
1528 /*-------------------------------------------------------------------*
1529 * ccw_check_unit_check *
1530 *--------------------------------------------------------------------*/
1531
1532 static void inline
1533 ccw_check_unit_check(struct chbk * p_ch, unsigned char sense )
1534 {
1535 struct net_device *dev = p_ch->ndev;
1536
1537 #ifdef FUNCTRACE
1538 printk(KERN_INFO "%s: %s() > enter\n",dev->name,__FUNCTION__);
1539 #endif
1540 #ifdef DEBUGMSG
1541 printk(KERN_INFO "%s: variable dev =\n",dev->name);
1542 dumpit((char *)dev, sizeof(struct net_device));
1543 printk(KERN_INFO "%s: variable sense =\n",dev->name);
1544 dumpit((char *)&sense, 2);
1545 #endif
1546 CLAW_DBF_TEXT(4,trace,"unitchek");
1547
1548 printk(KERN_INFO "%s: Unit Check with sense byte:0x%04x\n",
1549 dev->name, sense);
1550
1551 if (sense & 0x40) {
1552 if (sense & 0x01) {
1553 printk(KERN_WARNING "%s: Interface disconnect or "
1554 "Selective reset "
1555 "occurred (remote side)\n", dev->name);
1556 }
1557 else {
1558 printk(KERN_WARNING "%s: System reset occured"
1559 " (remote side)\n", dev->name);
1560 }
1561 }
1562 else if (sense & 0x20) {
1563 if (sense & 0x04) {
1564 printk(KERN_WARNING "%s: Data-streaming "
1565 "timeout)\n", dev->name);
1566 }
1567 else {
1568 printk(KERN_WARNING "%s: Data-transfer parity"
1569 " error\n", dev->name);
1570 }
1571 }
1572 else if (sense & 0x10) {
1573 if (sense & 0x20) {
1574 printk(KERN_WARNING "%s: Hardware malfunction "
1575 "(remote side)\n", dev->name);
1576 }
1577 else {
1578 printk(KERN_WARNING "%s: read-data parity error "
1579 "(remote side)\n", dev->name);
1580 }
1581 }
1582
1583 #ifdef FUNCTRACE
1584 printk(KERN_INFO "%s: %s() exit on line %d\n",
1585 dev->name,__FUNCTION__,__LINE__);
1586 #endif
1587 } /* end of ccw_check_unit_check */
1588
1589
1590
1591 /*-------------------------------------------------------------------*
1592 * Dump buffer format *
1593 * *
1594 *--------------------------------------------------------------------*/
1595 #ifdef DEBUG
1596 static void
1597 dumpit(char* buf, int len)
1598 {
1599
1600 __u32 ct, sw, rm, dup;
1601 char *ptr, *rptr;
1602 char tbuf[82], tdup[82];
1603 #if (CONFIG_64BIT)
1604 char addr[22];
1605 #else
1606 char addr[12];
1607 #endif
1608 char boff[12];
1609 char bhex[82], duphex[82];
1610 char basc[40];
1611
1612 sw = 0;
1613 rptr =ptr=buf;
1614 rm = 16;
1615 duphex[0] = 0x00;
1616 dup = 0;
1617 for ( ct=0; ct < len; ct++, ptr++, rptr++ ) {
1618 if (sw == 0) {
1619 #if (CONFIG_64BIT)
1620 sprintf(addr, "%16.16lX",(unsigned long)rptr);
1621 #else
1622 sprintf(addr, "%8.8X",(__u32)rptr);
1623 #endif
1624 sprintf(boff, "%4.4X", (__u32)ct);
1625 bhex[0] = '\0';
1626 basc[0] = '\0';
1627 }
1628 if ((sw == 4) || (sw == 12)) {
1629 strcat(bhex, " ");
1630 }
1631 if (sw == 8) {
1632 strcat(bhex, " ");
1633 }
1634 #if (CONFIG_64BIT)
1635 sprintf(tbuf,"%2.2lX", (unsigned long)*ptr);
1636 #else
1637 sprintf(tbuf,"%2.2X", (__u32)*ptr);
1638 #endif
1639 tbuf[2] = '\0';
1640 strcat(bhex, tbuf);
1641 if ((0!=isprint(*ptr)) && (*ptr >= 0x20)) {
1642 basc[sw] = *ptr;
1643 }
1644 else {
1645 basc[sw] = '.';
1646 }
1647 basc[sw+1] = '\0';
1648 sw++;
1649 rm--;
1650 if (sw==16) {
1651 if ((strcmp(duphex, bhex)) !=0) {
1652 if (dup !=0) {
1653 sprintf(tdup,"Duplicate as above to"
1654 " %s", addr);
1655 printk( KERN_INFO " "
1656 " --- %s ---\n",tdup);
1657 }
1658 printk( KERN_INFO " %s (+%s) : %s [%s]\n",
1659 addr, boff, bhex, basc);
1660 dup = 0;
1661 strcpy(duphex, bhex);
1662 }
1663 else {
1664 dup++;
1665 }
1666 sw = 0;
1667 rm = 16;
1668 }
1669 } /* endfor */
1670
1671 if (sw != 0) {
1672 for ( ; rm > 0; rm--, sw++ ) {
1673 if ((sw==4) || (sw==12)) strcat(bhex, " ");
1674 if (sw==8) strcat(bhex, " ");
1675 strcat(bhex, " ");
1676 strcat(basc, " ");
1677 }
1678 if (dup !=0) {
1679 sprintf(tdup,"Duplicate as above to %s", addr);
1680 printk( KERN_INFO " --- %s ---\n",
1681 tdup);
1682 }
1683 printk( KERN_INFO " %s (+%s) : %s [%s]\n",
1684 addr, boff, bhex, basc);
1685 }
1686 else {
1687 if (dup >=1) {
1688 sprintf(tdup,"Duplicate as above to %s", addr);
1689 printk( KERN_INFO " --- %s ---\n",
1690 tdup);
1691 }
1692 if (dup !=0) {
1693 printk( KERN_INFO " %s (+%s) : %s [%s]\n",
1694 addr, boff, bhex, basc);
1695 }
1696 }
1697 return;
1698
1699 } /* end of dumpit */
1700 #endif
1701
1702 /*-------------------------------------------------------------------*
1703 * find_link *
1704 *--------------------------------------------------------------------*/
1705 static int
1706 find_link(struct net_device *dev, char *host_name, char *ws_name )
1707 {
1708 struct claw_privbk *privptr;
1709 struct claw_env *p_env;
1710 int rc=0;
1711
1712 #ifdef FUNCTRACE
1713 printk(KERN_INFO "%s:%s > enter \n",dev->name,__FUNCTION__);
1714 #endif
1715 CLAW_DBF_TEXT(2,setup,"findlink");
1716 #ifdef DEBUGMSG
1717 printk(KERN_INFO "%s: variable dev = \n",dev->name);
1718 dumpit((char *) dev, sizeof(struct net_device));
1719 printk(KERN_INFO "%s: variable host_name = %s\n",dev->name, host_name);
1720 printk(KERN_INFO "%s: variable ws_name = %s\n",dev->name, ws_name);
1721 #endif
1722 privptr=dev->priv;
1723 p_env=privptr->p_env;
1724 switch (p_env->packing)
1725 {
1726 case PACKING_ASK:
1727 if ((memcmp(WS_APPL_NAME_PACKED, host_name, 8)!=0) ||
1728 (memcmp(WS_APPL_NAME_PACKED, ws_name, 8)!=0 ))
1729 rc = EINVAL;
1730 break;
1731 case DO_PACKED:
1732 case PACK_SEND:
1733 if ((memcmp(WS_APPL_NAME_IP_NAME, host_name, 8)!=0) ||
1734 (memcmp(WS_APPL_NAME_IP_NAME, ws_name, 8)!=0 ))
1735 rc = EINVAL;
1736 break;
1737 default:
1738 if ((memcmp(HOST_APPL_NAME, host_name, 8)!=0) ||
1739 (memcmp(p_env->api_type , ws_name, 8)!=0))
1740 rc = EINVAL;
1741 break;
1742 }
1743
1744 #ifdef FUNCTRACE
1745 printk(KERN_INFO "%s:%s Exit on line %d\n",
1746 dev->name,__FUNCTION__,__LINE__);
1747 #endif
1748 return 0;
1749 } /* end of find_link */
1750
1751 /*-------------------------------------------------------------------*
1752 * claw_hw_tx *
1753 * *
1754 * *
1755 *-------------------------------------------------------------------*/
1756
1757 static int
1758 claw_hw_tx(struct sk_buff *skb, struct net_device *dev, long linkid)
1759 {
1760 int rc=0;
1761 struct claw_privbk *privptr;
1762 struct ccwbk *p_this_ccw;
1763 struct ccwbk *p_first_ccw;
1764 struct ccwbk *p_last_ccw;
1765 __u32 numBuffers;
1766 signed long len_of_data;
1767 unsigned long bytesInThisBuffer;
1768 unsigned char *pDataAddress;
1769 struct endccw *pEnd;
1770 struct ccw1 tempCCW;
1771 struct chbk *p_ch;
1772 struct claw_env *p_env;
1773 int lock;
1774 struct clawph *pk_head;
1775 struct chbk *ch;
1776 #ifdef IOTRACE
1777 struct ccwbk *p_buf;
1778 #endif
1779 #ifdef FUNCTRACE
1780 printk(KERN_INFO "%s: %s() > enter\n",dev->name,__FUNCTION__);
1781 #endif
1782 CLAW_DBF_TEXT(4,trace,"hw_tx");
1783 #ifdef DEBUGMSG
1784 printk(KERN_INFO "%s: variable dev skb =\n",dev->name);
1785 dumpit((char *) skb, sizeof(struct sk_buff));
1786 printk(KERN_INFO "%s: variable dev =\n",dev->name);
1787 dumpit((char *) dev, sizeof(struct net_device));
1788 printk(KERN_INFO "%s: variable linkid = %ld\n",dev->name,linkid);
1789 #endif
1790 privptr = (struct claw_privbk *) (dev->priv);
1791 p_ch=(struct chbk *)&privptr->channel[WRITE];
1792 p_env =privptr->p_env;
1793 #ifdef IOTRACE
1794 printk(KERN_INFO "%s: %s() dump sk_buff \n",dev->name,__FUNCTION__);
1795 dumpit((char *)skb ,sizeof(struct sk_buff));
1796 #endif
1797 claw_free_wrt_buf(dev); /* Clean up free chain if posible */
1798 /* scan the write queue to free any completed write packets */
1799 p_first_ccw=NULL;
1800 p_last_ccw=NULL;
1801 if ((p_env->packing >= PACK_SEND) &&
1802 (skb->cb[1] != 'P')) {
1803 skb_push(skb,sizeof(struct clawph));
1804 pk_head=(struct clawph *)skb->data;
1805 pk_head->len=skb->len-sizeof(struct clawph);
1806 if (pk_head->len%4) {
1807 pk_head->len+= 4-(pk_head->len%4);
1808 skb_pad(skb,4-(pk_head->len%4));
1809 skb_put(skb,4-(pk_head->len%4));
1810 }
1811 if (p_env->packing == DO_PACKED)
1812 pk_head->link_num = linkid;
1813 else
1814 pk_head->link_num = 0;
1815 pk_head->flag = 0x00;
1816 skb_pad(skb,4);
1817 skb->cb[1] = 'P';
1818 }
1819 if (linkid == 0) {
1820 if (claw_check_busy(dev)) {
1821 if (privptr->write_free_count!=0) {
1822 claw_clear_busy(dev);
1823 }
1824 else {
1825 claw_strt_out_IO(dev );
1826 claw_free_wrt_buf( dev );
1827 if (privptr->write_free_count==0) {
1828 #ifdef IOTRACE
1829 printk(KERN_INFO "%s: "
1830 "(claw_check_busy) no free write "
1831 "buffers\n", dev->name);
1832 #endif
1833 ch = &privptr->channel[WRITE];
1834 atomic_inc(&skb->users);
1835 skb_queue_tail(&ch->collect_queue, skb);
1836 goto Done;
1837 }
1838 else {
1839 claw_clear_busy(dev);
1840 }
1841 }
1842 }
1843 /* tx lock */
1844 if (claw_test_and_setbit_busy(TB_TX,dev)) { /* set to busy */
1845 #ifdef DEBUGMSG
1846 printk(KERN_INFO "%s: busy (claw_test_and_setbit_"
1847 "busy)\n", dev->name);
1848 #endif
1849 ch = &privptr->channel[WRITE];
1850 atomic_inc(&skb->users);
1851 skb_queue_tail(&ch->collect_queue, skb);
1852 claw_strt_out_IO(dev );
1853 rc=-EBUSY;
1854 goto Done2;
1855 }
1856 }
1857 /* See how many write buffers are required to hold this data */
1858 numBuffers= ( skb->len + privptr->p_env->write_size - 1) /
1859 ( privptr->p_env->write_size);
1860
1861 /* If that number of buffers isn't available, give up for now */
1862 if (privptr->write_free_count < numBuffers ||
1863 privptr->p_write_free_chain == NULL ) {
1864
1865 claw_setbit_busy(TB_NOBUFFER,dev);
1866
1867 #ifdef DEBUGMSG
1868 printk(KERN_INFO "%s: busy (claw_setbit_busy"
1869 "(TB_NOBUFFER))\n", dev->name);
1870 printk(KERN_INFO " free_count: %d, numBuffers : %d\n",
1871 (int)privptr->write_free_count,(int) numBuffers );
1872 #endif
1873 ch = &privptr->channel[WRITE];
1874 atomic_inc(&skb->users);
1875 skb_queue_tail(&ch->collect_queue, skb);
1876 CLAW_DBF_TEXT(2,trace,"clawbusy");
1877 goto Done2;
1878 }
1879 pDataAddress=skb->data;
1880 len_of_data=skb->len;
1881
1882 while (len_of_data > 0) {
1883 #ifdef DEBUGMSG
1884 printk(KERN_INFO "%s: %s() length-of-data is %ld \n",
1885 dev->name ,__FUNCTION__,len_of_data);
1886 dumpit((char *)pDataAddress ,64);
1887 #endif
1888 p_this_ccw=privptr->p_write_free_chain; /* get a block */
1889 if (p_this_ccw == NULL) { /* lost the race */
1890 ch = &privptr->channel[WRITE];
1891 atomic_inc(&skb->users);
1892 skb_queue_tail(&ch->collect_queue, skb);
1893 goto Done2;
1894 }
1895 privptr->p_write_free_chain=p_this_ccw->next;
1896 p_this_ccw->next=NULL;
1897 --privptr->write_free_count; /* -1 */
1898 bytesInThisBuffer=len_of_data;
1899 memcpy( p_this_ccw->p_buffer,pDataAddress, bytesInThisBuffer);
1900 len_of_data-=bytesInThisBuffer;
1901 pDataAddress+=(unsigned long)bytesInThisBuffer;
1902 /* setup write CCW */
1903 p_this_ccw->write.cmd_code = (linkid * 8) +1;
1904 if (len_of_data>0) {
1905 p_this_ccw->write.cmd_code+=MORE_to_COME_FLAG;
1906 }
1907 p_this_ccw->write.count=bytesInThisBuffer;
1908 /* now add to end of this chain */
1909 if (p_first_ccw==NULL) {
1910 p_first_ccw=p_this_ccw;
1911 }
1912 if (p_last_ccw!=NULL) {
1913 p_last_ccw->next=p_this_ccw;
1914 /* set up TIC ccws */
1915 p_last_ccw->w_TIC_1.cda=
1916 (__u32)__pa(&p_this_ccw->write);
1917 }
1918 p_last_ccw=p_this_ccw; /* save new last block */
1919 #ifdef IOTRACE
1920 printk(KERN_INFO "%s: %s() > CCW and Buffer %ld bytes long \n",
1921 dev->name,__FUNCTION__,bytesInThisBuffer);
1922 dumpit((char *)p_this_ccw, sizeof(struct ccwbk));
1923 dumpit((char *)p_this_ccw->p_buffer, 64);
1924 #endif
1925 }
1926
1927 /* FirstCCW and LastCCW now contain a new set of write channel
1928 * programs to append to the running channel program
1929 */
1930
1931 if (p_first_ccw!=NULL) {
1932 /* setup ending ccw sequence for this segment */
1933 pEnd=privptr->p_end_ccw;
1934 if (pEnd->write1) {
1935 pEnd->write1=0x00; /* second end ccw is now active */
1936 /* set up Tic CCWs */
1937 p_last_ccw->w_TIC_1.cda=
1938 (__u32)__pa(&pEnd->write2_nop1);
1939 pEnd->write2_nop2.cmd_code = CCW_CLAW_CMD_READFF;
1940 pEnd->write2_nop2.flags =
1941 CCW_FLAG_SLI | CCW_FLAG_SKIP;
1942 pEnd->write2_nop2.cda=0;
1943 pEnd->write2_nop2.count=1;
1944 }
1945 else { /* end of if (pEnd->write1)*/
1946 pEnd->write1=0x01; /* first end ccw is now active */
1947 /* set up Tic CCWs */
1948 p_last_ccw->w_TIC_1.cda=
1949 (__u32)__pa(&pEnd->write1_nop1);
1950 pEnd->write1_nop2.cmd_code = CCW_CLAW_CMD_READFF;
1951 pEnd->write1_nop2.flags =
1952 CCW_FLAG_SLI | CCW_FLAG_SKIP;
1953 pEnd->write1_nop2.cda=0;
1954 pEnd->write1_nop2.count=1;
1955 } /* end if if (pEnd->write1) */
1956
1957
1958 if (privptr->p_write_active_first==NULL ) {
1959 privptr->p_write_active_first=p_first_ccw;
1960 privptr->p_write_active_last=p_last_ccw;
1961 }
1962 else {
1963
1964 /* set up Tic CCWs */
1965
1966 tempCCW.cda=(__u32)__pa(&p_first_ccw->write);
1967 tempCCW.count=0;
1968 tempCCW.flags=0;
1969 tempCCW.cmd_code=CCW_CLAW_CMD_TIC;
1970
1971 if (pEnd->write1) {
1972
1973 /*
1974 * first set of ending CCW's is chained to the new write
1975 * chain, so the second set is chained to the active chain
1976 * Therefore modify the second set to point the new write chain.
1977 * make sure we update the CCW atomically
1978 * so channel does not fetch it when it's only half done
1979 */
1980 memcpy( &pEnd->write2_nop2, &tempCCW ,
1981 sizeof(struct ccw1));
1982 privptr->p_write_active_last->w_TIC_1.cda=
1983 (__u32)__pa(&p_first_ccw->write);
1984 }
1985 else {
1986
1987 /*make sure we update the CCW atomically
1988 *so channel does not fetch it when it's only half done
1989 */
1990 memcpy(&pEnd->write1_nop2, &tempCCW ,
1991 sizeof(struct ccw1));
1992 privptr->p_write_active_last->w_TIC_1.cda=
1993 (__u32)__pa(&p_first_ccw->write);
1994
1995 } /* end if if (pEnd->write1) */
1996
1997 privptr->p_write_active_last->next=p_first_ccw;
1998 privptr->p_write_active_last=p_last_ccw;
1999 }
2000
2001 } /* endif (p_first_ccw!=NULL) */
2002
2003
2004 #ifdef IOTRACE
2005 printk(KERN_INFO "%s: %s() > Dump Active CCW chain \n",
2006 dev->name,__FUNCTION__);
2007 p_buf=privptr->p_write_active_first;
2008 while (p_buf!=NULL) {
2009 dumpit((char *)p_buf, sizeof(struct ccwbk));
2010 p_buf=p_buf->next;
2011 }
2012 p_buf=(struct ccwbk*)privptr->p_end_ccw;
2013 dumpit((char *)p_buf, sizeof(struct endccw));
2014 #endif
2015 dev_kfree_skb_any(skb);
2016 if (linkid==0) {
2017 lock=LOCK_NO;
2018 }
2019 else {
2020 lock=LOCK_YES;
2021 }
2022 claw_strt_out_IO(dev );
2023 /* if write free count is zero , set NOBUFFER */
2024 #ifdef DEBUGMSG
2025 printk(KERN_INFO "%s: %s() > free_count is %d\n",
2026 dev->name,__FUNCTION__,
2027 (int) privptr->write_free_count );
2028 #endif
2029 if (privptr->write_free_count==0) {
2030 claw_setbit_busy(TB_NOBUFFER,dev);
2031 }
2032 Done2:
2033 claw_clearbit_busy(TB_TX,dev);
2034 Done:
2035 #ifdef FUNCTRACE
2036 printk(KERN_INFO "%s: %s() > exit on line %d, rc = %d \n",
2037 dev->name,__FUNCTION__,__LINE__, rc);
2038 #endif
2039 return(rc);
2040 } /* end of claw_hw_tx */
2041
2042 /*-------------------------------------------------------------------*
2043 * *
2044 * init_ccw_bk *
2045 * *
2046 *--------------------------------------------------------------------*/
2047
2048 static int
2049 init_ccw_bk(struct net_device *dev)
2050 {
2051
2052 __u32 ccw_blocks_required;
2053 __u32 ccw_blocks_perpage;
2054 __u32 ccw_pages_required;
2055 __u32 claw_reads_perpage=1;
2056 __u32 claw_read_pages;
2057 __u32 claw_writes_perpage=1;
2058 __u32 claw_write_pages;
2059 void *p_buff=NULL;
2060 struct ccwbk*p_free_chain;
2061 struct ccwbk*p_buf;
2062 struct ccwbk*p_last_CCWB;
2063 struct ccwbk*p_first_CCWB;
2064 struct endccw *p_endccw=NULL;
2065 addr_t real_address;
2066 struct claw_privbk *privptr=dev->priv;
2067 struct clawh *pClawH=NULL;
2068 addr_t real_TIC_address;
2069 int i,j;
2070 #ifdef FUNCTRACE
2071 printk(KERN_INFO "%s: %s() enter \n",dev->name,__FUNCTION__);
2072 #endif
2073 CLAW_DBF_TEXT(4,trace,"init_ccw");
2074 #ifdef DEBUGMSG
2075 printk(KERN_INFO "%s: variable dev =\n",dev->name);
2076 dumpit((char *) dev, sizeof(struct net_device));
2077 #endif
2078
2079 /* initialize statistics field */
2080 privptr->active_link_ID=0;
2081 /* initialize ccwbk pointers */
2082 privptr->p_write_free_chain=NULL; /* pointer to free ccw chain*/
2083 privptr->p_write_active_first=NULL; /* pointer to the first write ccw*/
2084 privptr->p_write_active_last=NULL; /* pointer to the last write ccw*/
2085 privptr->p_read_active_first=NULL; /* pointer to the first read ccw*/
2086 privptr->p_read_active_last=NULL; /* pointer to the last read ccw */
2087 privptr->p_end_ccw=NULL; /* pointer to ending ccw */
2088 privptr->p_claw_signal_blk=NULL; /* pointer to signal block */
2089 privptr->buffs_alloc = 0;
2090 memset(&privptr->end_ccw, 0x00, sizeof(struct endccw));
2091 memset(&privptr->ctl_bk, 0x00, sizeof(struct clawctl));
2092 /* initialize free write ccwbk counter */
2093 privptr->write_free_count=0; /* number of free bufs on write chain */
2094 p_last_CCWB = NULL;
2095 p_first_CCWB= NULL;
2096 /*
2097 * We need 1 CCW block for each read buffer, 1 for each
2098 * write buffer, plus 1 for ClawSignalBlock
2099 */
2100 ccw_blocks_required =
2101 privptr->p_env->read_buffers+privptr->p_env->write_buffers+1;
2102 #ifdef DEBUGMSG
2103 printk(KERN_INFO "%s: %s() "
2104 "ccw_blocks_required=%d\n",
2105 dev->name,__FUNCTION__,
2106 ccw_blocks_required);
2107 printk(KERN_INFO "%s: %s() "
2108 "PAGE_SIZE=0x%x\n",
2109 dev->name,__FUNCTION__,
2110 (unsigned int)PAGE_SIZE);
2111 printk(KERN_INFO "%s: %s() > "
2112 "PAGE_MASK=0x%x\n",
2113 dev->name,__FUNCTION__,
2114 (unsigned int)PAGE_MASK);
2115 #endif
2116 /*
2117 * compute number of CCW blocks that will fit in a page
2118 */
2119 ccw_blocks_perpage= PAGE_SIZE / CCWBK_SIZE;
2120 ccw_pages_required=
2121 (ccw_blocks_required+ccw_blocks_perpage -1) /
2122 ccw_blocks_perpage;
2123
2124 #ifdef DEBUGMSG
2125 printk(KERN_INFO "%s: %s() > ccw_blocks_perpage=%d\n",
2126 dev->name,__FUNCTION__,
2127 ccw_blocks_perpage);
2128 printk(KERN_INFO "%s: %s() > ccw_pages_required=%d\n",
2129 dev->name,__FUNCTION__,
2130 ccw_pages_required);
2131 #endif
2132 /*
2133 * read and write sizes are set by 2 constants in claw.h
2134 * 4k and 32k. Unpacked values other than 4k are not going to
2135 * provide good performance. With packing buffers support 32k
2136 * buffers are used.
2137 */
2138 if (privptr->p_env->read_size < PAGE_SIZE) {
2139 claw_reads_perpage= PAGE_SIZE / privptr->p_env->read_size;
2140 claw_read_pages= (privptr->p_env->read_buffers +
2141 claw_reads_perpage -1) / claw_reads_perpage;
2142 }
2143 else { /* > or equal */
2144 privptr->p_buff_pages_perread=
2145 (privptr->p_env->read_size + PAGE_SIZE - 1) / PAGE_SIZE;
2146 claw_read_pages=
2147 privptr->p_env->read_buffers * privptr->p_buff_pages_perread;
2148 }
2149 if (privptr->p_env->write_size < PAGE_SIZE) {
2150 claw_writes_perpage=
2151 PAGE_SIZE / privptr->p_env->write_size;
2152 claw_write_pages=
2153 (privptr->p_env->write_buffers + claw_writes_perpage -1) /
2154 claw_writes_perpage;
2155
2156 }
2157 else { /* > or equal */
2158 privptr->p_buff_pages_perwrite=
2159 (privptr->p_env->read_size + PAGE_SIZE - 1) / PAGE_SIZE;
2160 claw_write_pages=
2161 privptr->p_env->write_buffers * privptr->p_buff_pages_perwrite;
2162 }
2163 #ifdef DEBUGMSG
2164 if (privptr->p_env->read_size < PAGE_SIZE) {
2165 printk(KERN_INFO "%s: %s() reads_perpage=%d\n",
2166 dev->name,__FUNCTION__,
2167 claw_reads_perpage);
2168 }
2169 else {
2170 printk(KERN_INFO "%s: %s() pages_perread=%d\n",
2171 dev->name,__FUNCTION__,
2172 privptr->p_buff_pages_perread);
2173 }
2174 printk(KERN_INFO "%s: %s() read_pages=%d\n",
2175 dev->name,__FUNCTION__,
2176 claw_read_pages);
2177 if (privptr->p_env->write_size < PAGE_SIZE) {
2178 printk(KERN_INFO "%s: %s() writes_perpage=%d\n",
2179 dev->name,__FUNCTION__,
2180 claw_writes_perpage);
2181 }
2182 else {
2183 printk(KERN_INFO "%s: %s() pages_perwrite=%d\n",
2184 dev->name,__FUNCTION__,
2185 privptr->p_buff_pages_perwrite);
2186 }
2187 printk(KERN_INFO "%s: %s() write_pages=%d\n",
2188 dev->name,__FUNCTION__,
2189 claw_write_pages);
2190 #endif
2191
2192
2193 /*
2194 * allocate ccw_pages_required
2195 */
2196 if (privptr->p_buff_ccw==NULL) {
2197 privptr->p_buff_ccw=
2198 (void *)__get_free_pages(__GFP_DMA,
2199 (int)pages_to_order_of_mag(ccw_pages_required ));
2200 if (privptr->p_buff_ccw==NULL) {
2201 printk(KERN_INFO "%s: %s() "
2202 "__get_free_pages for CCWs failed : "
2203 "pages is %d\n",
2204 dev->name,__FUNCTION__,
2205 ccw_pages_required );
2206 #ifdef FUNCTRACE
2207 printk(KERN_INFO "%s: %s() > "
2208 "exit on line %d, rc = ENOMEM\n",
2209 dev->name,__FUNCTION__,
2210 __LINE__);
2211 #endif
2212 return -ENOMEM;
2213 }
2214 privptr->p_buff_ccw_num=ccw_pages_required;
2215 }
2216 memset(privptr->p_buff_ccw, 0x00,
2217 privptr->p_buff_ccw_num * PAGE_SIZE);
2218
2219 /*
2220 * obtain ending ccw block address
2221 *
2222 */
2223 privptr->p_end_ccw = (struct endccw *)&privptr->end_ccw;
2224 real_address = (__u32)__pa(privptr->p_end_ccw);
2225 /* Initialize ending CCW block */
2226 #ifdef DEBUGMSG
2227 printk(KERN_INFO "%s: %s() begin initialize ending CCW blocks\n",
2228 dev->name,__FUNCTION__);
2229 #endif
2230
2231 p_endccw=privptr->p_end_ccw;
2232 p_endccw->real=real_address;
2233 p_endccw->write1=0x00;
2234 p_endccw->read1=0x00;
2235
2236 /* write1_nop1 */
2237 p_endccw->write1_nop1.cmd_code = CCW_CLAW_CMD_NOP;
2238 p_endccw->write1_nop1.flags = CCW_FLAG_SLI | CCW_FLAG_CC;
2239 p_endccw->write1_nop1.count = 1;
2240 p_endccw->write1_nop1.cda = 0;
2241
2242 /* write1_nop2 */
2243 p_endccw->write1_nop2.cmd_code = CCW_CLAW_CMD_READFF;
2244 p_endccw->write1_nop2.flags = CCW_FLAG_SLI | CCW_FLAG_SKIP;
2245 p_endccw->write1_nop2.count = 1;
2246 p_endccw->write1_nop2.cda = 0;
2247
2248 /* write2_nop1 */
2249 p_endccw->write2_nop1.cmd_code = CCW_CLAW_CMD_NOP;
2250 p_endccw->write2_nop1.flags = CCW_FLAG_SLI | CCW_FLAG_CC;
2251 p_endccw->write2_nop1.count = 1;
2252 p_endccw->write2_nop1.cda = 0;
2253
2254 /* write2_nop2 */
2255 p_endccw->write2_nop2.cmd_code = CCW_CLAW_CMD_READFF;
2256 p_endccw->write2_nop2.flags = CCW_FLAG_SLI | CCW_FLAG_SKIP;
2257 p_endccw->write2_nop2.count = 1;
2258 p_endccw->write2_nop2.cda = 0;
2259
2260 /* read1_nop1 */
2261 p_endccw->read1_nop1.cmd_code = CCW_CLAW_CMD_NOP;
2262 p_endccw->read1_nop1.flags = CCW_FLAG_SLI | CCW_FLAG_CC;
2263 p_endccw->read1_nop1.count = 1;
2264 p_endccw->read1_nop1.cda = 0;
2265
2266 /* read1_nop2 */
2267 p_endccw->read1_nop2.cmd_code = CCW_CLAW_CMD_READFF;
2268 p_endccw->read1_nop2.flags = CCW_FLAG_SLI | CCW_FLAG_SKIP;
2269 p_endccw->read1_nop2.count = 1;
2270 p_endccw->read1_nop2.cda = 0;
2271
2272 /* read2_nop1 */
2273 p_endccw->read2_nop1.cmd_code = CCW_CLAW_CMD_NOP;
2274 p_endccw->read2_nop1.flags = CCW_FLAG_SLI | CCW_FLAG_CC;
2275 p_endccw->read2_nop1.count = 1;
2276 p_endccw->read2_nop1.cda = 0;
2277
2278 /* read2_nop2 */
2279 p_endccw->read2_nop2.cmd_code = CCW_CLAW_CMD_READFF;
2280 p_endccw->read2_nop2.flags = CCW_FLAG_SLI | CCW_FLAG_SKIP;
2281 p_endccw->read2_nop2.count = 1;
2282 p_endccw->read2_nop2.cda = 0;
2283
2284 #ifdef IOTRACE
2285 printk(KERN_INFO "%s: %s() dump claw ending CCW BK \n",
2286 dev->name,__FUNCTION__);
2287 dumpit((char *)p_endccw, sizeof(struct endccw));
2288 #endif
2289
2290 /*
2291 * Build a chain of CCWs
2292 *
2293 */
2294
2295 #ifdef DEBUGMSG
2296 printk(KERN_INFO "%s: %s() Begin build a chain of CCW buffer \n",
2297 dev->name,__FUNCTION__);
2298 #endif
2299 p_buff=privptr->p_buff_ccw;
2300
2301 p_free_chain=NULL;
2302 for (i=0 ; i < ccw_pages_required; i++ ) {
2303 real_address = (__u32)__pa(p_buff);
2304 p_buf=p_buff;
2305 for (j=0 ; j < ccw_blocks_perpage ; j++) {
2306 p_buf->next = p_free_chain;
2307 p_free_chain = p_buf;
2308 p_buf->real=(__u32)__pa(p_buf);
2309 ++p_buf;
2310 }
2311 p_buff+=PAGE_SIZE;
2312 }
2313 #ifdef DEBUGMSG
2314 printk(KERN_INFO "%s: %s() "
2315 "End build a chain of CCW buffer \n",
2316 dev->name,__FUNCTION__);
2317 p_buf=p_free_chain;
2318 while (p_buf!=NULL) {
2319 dumpit((char *)p_buf, sizeof(struct ccwbk));
2320 p_buf=p_buf->next;
2321 }
2322 #endif
2323
2324 /*
2325 * Initialize ClawSignalBlock
2326 *
2327 */
2328 #ifdef DEBUGMSG
2329 printk(KERN_INFO "%s: %s() "
2330 "Begin initialize ClawSignalBlock \n",
2331 dev->name,__FUNCTION__);
2332 #endif
2333 if (privptr->p_claw_signal_blk==NULL) {
2334 privptr->p_claw_signal_blk=p_free_chain;
2335 p_free_chain=p_free_chain->next;
2336 pClawH=(struct clawh *)privptr->p_claw_signal_blk;
2337 pClawH->length=0xffff;
2338 pClawH->opcode=0xff;
2339 pClawH->flag=CLAW_BUSY;
2340 }
2341 #ifdef DEBUGMSG
2342 printk(KERN_INFO "%s: %s() > End initialize "
2343 "ClawSignalBlock\n",
2344 dev->name,__FUNCTION__);
2345 dumpit((char *)privptr->p_claw_signal_blk, sizeof(struct ccwbk));
2346 #endif
2347
2348 /*
2349 * allocate write_pages_required and add to free chain
2350 */
2351 if (privptr->p_buff_write==NULL) {
2352 if (privptr->p_env->write_size < PAGE_SIZE) {
2353 privptr->p_buff_write=
2354 (void *)__get_free_pages(__GFP_DMA,
2355 (int)pages_to_order_of_mag(claw_write_pages ));
2356 if (privptr->p_buff_write==NULL) {
2357 printk(KERN_INFO "%s: %s() __get_free_pages for write"
2358 " bufs failed : get is for %d pages\n",
2359 dev->name,__FUNCTION__,claw_write_pages );
2360 free_pages((unsigned long)privptr->p_buff_ccw,
2361 (int)pages_to_order_of_mag(privptr->p_buff_ccw_num));
2362 privptr->p_buff_ccw=NULL;
2363 #ifdef FUNCTRACE
2364 printk(KERN_INFO "%s: %s() > exit on line %d,"
2365 "rc = ENOMEM\n",
2366 dev->name,__FUNCTION__,__LINE__);
2367 #endif
2368 return -ENOMEM;
2369 }
2370 /*
2371 * Build CLAW write free chain
2372 *
2373 */
2374
2375 memset(privptr->p_buff_write, 0x00,
2376 ccw_pages_required * PAGE_SIZE);
2377 #ifdef DEBUGMSG
2378 printk(KERN_INFO "%s: %s() Begin build claw write free "
2379 "chain \n",dev->name,__FUNCTION__);
2380 #endif
2381 privptr->p_write_free_chain=NULL;
2382
2383 p_buff=privptr->p_buff_write;
2384
2385 for (i=0 ; i< privptr->p_env->write_buffers ; i++) {
2386 p_buf = p_free_chain; /* get a CCW */
2387 p_free_chain = p_buf->next;
2388 p_buf->next =privptr->p_write_free_chain;
2389 privptr->p_write_free_chain = p_buf;
2390 p_buf-> p_buffer = (struct clawbuf *)p_buff;
2391 p_buf-> write.cda = (__u32)__pa(p_buff);
2392 p_buf-> write.flags = CCW_FLAG_SLI | CCW_FLAG_CC;
2393 p_buf-> w_read_FF.cmd_code = CCW_CLAW_CMD_READFF;
2394 p_buf-> w_read_FF.flags = CCW_FLAG_SLI | CCW_FLAG_CC;
2395 p_buf-> w_read_FF.count = 1;
2396 p_buf-> w_read_FF.cda =
2397 (__u32)__pa(&p_buf-> header.flag);
2398 p_buf-> w_TIC_1.cmd_code = CCW_CLAW_CMD_TIC;
2399 p_buf-> w_TIC_1.flags = 0;
2400 p_buf-> w_TIC_1.count = 0;
2401
2402 if (((unsigned long)p_buff+privptr->p_env->write_size) >=
2403 ((unsigned long)(p_buff+2*
2404 (privptr->p_env->write_size) -1) & PAGE_MASK)) {
2405 p_buff= p_buff+privptr->p_env->write_size;
2406 }
2407 }
2408 }
2409 else /* Buffers are => PAGE_SIZE. 1 buff per get_free_pages */
2410 {
2411 privptr->p_write_free_chain=NULL;
2412 for (i = 0; i< privptr->p_env->write_buffers ; i++) {
2413 p_buff=(void *)__get_free_pages(__GFP_DMA,
2414 (int)pages_to_order_of_mag(
2415 privptr->p_buff_pages_perwrite) );
2416 #ifdef IOTRACE
2417 printk(KERN_INFO "%s:%s __get_free_pages "
2418 "for writes buf: get for %d pages\n",
2419 dev->name,__FUNCTION__,
2420 privptr->p_buff_pages_perwrite);
2421 #endif
2422 if (p_buff==NULL) {
2423 printk(KERN_INFO "%s:%s __get_free_pages"
2424 "for writes buf failed : get is for %d pages\n",
2425 dev->name,
2426 __FUNCTION__,
2427 privptr->p_buff_pages_perwrite );
2428 free_pages((unsigned long)privptr->p_buff_ccw,
2429 (int)pages_to_order_of_mag(
2430 privptr->p_buff_ccw_num));
2431 privptr->p_buff_ccw=NULL;
2432 p_buf=privptr->p_buff_write;
2433 while (p_buf!=NULL) {
2434 free_pages((unsigned long)
2435 p_buf->p_buffer,
2436 (int)pages_to_order_of_mag(
2437 privptr->p_buff_pages_perwrite));
2438 p_buf=p_buf->next;
2439 }
2440 #ifdef FUNCTRACE
2441 printk(KERN_INFO "%s: %s exit on line %d, rc = ENOMEM\n",
2442 dev->name,
2443 __FUNCTION__,
2444 __LINE__);
2445 #endif
2446 return -ENOMEM;
2447 } /* Error on get_pages */
2448 memset(p_buff, 0x00, privptr->p_env->write_size );
2449 p_buf = p_free_chain;
2450 p_free_chain = p_buf->next;
2451 p_buf->next = privptr->p_write_free_chain;
2452 privptr->p_write_free_chain = p_buf;
2453 privptr->p_buff_write = p_buf;
2454 p_buf->p_buffer=(struct clawbuf *)p_buff;
2455 p_buf-> write.cda = (__u32)__pa(p_buff);
2456 p_buf-> write.flags = CCW_FLAG_SLI | CCW_FLAG_CC;
2457 p_buf-> w_read_FF.cmd_code = CCW_CLAW_CMD_READFF;
2458 p_buf-> w_read_FF.flags = CCW_FLAG_SLI | CCW_FLAG_CC;
2459 p_buf-> w_read_FF.count = 1;
2460 p_buf-> w_read_FF.cda =
2461 (__u32)__pa(&p_buf-> header.flag);
2462 p_buf-> w_TIC_1.cmd_code = CCW_CLAW_CMD_TIC;
2463 p_buf-> w_TIC_1.flags = 0;
2464 p_buf-> w_TIC_1.count = 0;
2465 } /* for all write_buffers */
2466
2467 } /* else buffers are PAGE_SIZE or bigger */
2468
2469 }
2470 privptr->p_buff_write_num=claw_write_pages;
2471 privptr->write_free_count=privptr->p_env->write_buffers;
2472
2473
2474 #ifdef DEBUGMSG
2475 printk(KERN_INFO "%s:%s End build claw write free chain \n",
2476 dev->name,__FUNCTION__);
2477 p_buf=privptr->p_write_free_chain;
2478 while (p_buf!=NULL) {
2479 dumpit((char *)p_buf, sizeof(struct ccwbk));
2480 p_buf=p_buf->next;
2481 }
2482 #endif
2483 /*
2484 * allocate read_pages_required and chain to free chain
2485 */
2486 if (privptr->p_buff_read==NULL) {
2487 if (privptr->p_env->read_size < PAGE_SIZE) {
2488 privptr->p_buff_read=
2489 (void *)__get_free_pages(__GFP_DMA,
2490 (int)pages_to_order_of_mag(claw_read_pages) );
2491 if (privptr->p_buff_read==NULL) {
2492 printk(KERN_INFO "%s: %s() "
2493 "__get_free_pages for read buf failed : "
2494 "get is for %d pages\n",
2495 dev->name,__FUNCTION__,claw_read_pages );
2496 free_pages((unsigned long)privptr->p_buff_ccw,
2497 (int)pages_to_order_of_mag(
2498 privptr->p_buff_ccw_num));
2499 /* free the write pages size is < page size */
2500 free_pages((unsigned long)privptr->p_buff_write,
2501 (int)pages_to_order_of_mag(
2502 privptr->p_buff_write_num));
2503 privptr->p_buff_ccw=NULL;
2504 privptr->p_buff_write=NULL;
2505 #ifdef FUNCTRACE
2506 printk(KERN_INFO "%s: %s() > exit on line %d, rc ="
2507 " ENOMEM\n",dev->name,__FUNCTION__,__LINE__);
2508 #endif
2509 return -ENOMEM;
2510 }
2511 memset(privptr->p_buff_read, 0x00, claw_read_pages * PAGE_SIZE);
2512 privptr->p_buff_read_num=claw_read_pages;
2513 /*
2514 * Build CLAW read free chain
2515 *
2516 */
2517 #ifdef DEBUGMSG
2518 printk(KERN_INFO "%s: %s() Begin build claw read free chain \n",
2519 dev->name,__FUNCTION__);
2520 #endif
2521 p_buff=privptr->p_buff_read;
2522 for (i=0 ; i< privptr->p_env->read_buffers ; i++) {
2523 p_buf = p_free_chain;
2524 p_free_chain = p_buf->next;
2525
2526 if (p_last_CCWB==NULL) {
2527 p_buf->next=NULL;
2528 real_TIC_address=0;
2529 p_last_CCWB=p_buf;
2530 }
2531 else {
2532 p_buf->next=p_first_CCWB;
2533 real_TIC_address=
2534 (__u32)__pa(&p_first_CCWB -> read );
2535 }
2536
2537 p_first_CCWB=p_buf;
2538
2539 p_buf->p_buffer=(struct clawbuf *)p_buff;
2540 /* initialize read command */
2541 p_buf-> read.cmd_code = CCW_CLAW_CMD_READ;
2542 p_buf-> read.cda = (__u32)__pa(p_buff);
2543 p_buf-> read.flags = CCW_FLAG_SLI | CCW_FLAG_CC;
2544 p_buf-> read.count = privptr->p_env->read_size;
2545
2546 /* initialize read_h command */
2547 p_buf-> read_h.cmd_code = CCW_CLAW_CMD_READHEADER;
2548 p_buf-> read_h.cda =
2549 (__u32)__pa(&(p_buf->header));
2550 p_buf-> read_h.flags = CCW_FLAG_SLI | CCW_FLAG_CC;
2551 p_buf-> read_h.count = sizeof(struct clawh);
2552
2553 /* initialize Signal command */
2554 p_buf-> signal.cmd_code = CCW_CLAW_CMD_SIGNAL_SMOD;
2555 p_buf-> signal.cda =
2556 (__u32)__pa(&(pClawH->flag));
2557 p_buf-> signal.flags = CCW_FLAG_SLI | CCW_FLAG_CC;
2558 p_buf-> signal.count = 1;
2559
2560 /* initialize r_TIC_1 command */
2561 p_buf-> r_TIC_1.cmd_code = CCW_CLAW_CMD_TIC;
2562 p_buf-> r_TIC_1.cda = (__u32)real_TIC_address;
2563 p_buf-> r_TIC_1.flags = 0;
2564 p_buf-> r_TIC_1.count = 0;
2565
2566 /* initialize r_read_FF command */
2567 p_buf-> r_read_FF.cmd_code = CCW_CLAW_CMD_READFF;
2568 p_buf-> r_read_FF.cda =
2569 (__u32)__pa(&(pClawH->flag));
2570 p_buf-> r_read_FF.flags =
2571 CCW_FLAG_SLI | CCW_FLAG_CC | CCW_FLAG_PCI;
2572 p_buf-> r_read_FF.count = 1;
2573
2574 /* initialize r_TIC_2 */
2575 memcpy(&p_buf->r_TIC_2,
2576 &p_buf->r_TIC_1, sizeof(struct ccw1));
2577
2578 /* initialize Header */
2579 p_buf->header.length=0xffff;
2580 p_buf->header.opcode=0xff;
2581 p_buf->header.flag=CLAW_PENDING;
2582
2583 if (((unsigned long)p_buff+privptr->p_env->read_size) >=
2584 ((unsigned long)(p_buff+2*(privptr->p_env->read_size) -1)
2585 & PAGE_MASK) ) {
2586 p_buff= p_buff+privptr->p_env->read_size;
2587 }
2588 else {
2589 p_buff=
2590 (void *)((unsigned long)
2591 (p_buff+2*(privptr->p_env->read_size) -1)
2592 & PAGE_MASK) ;
2593 }
2594 } /* for read_buffers */
2595 } /* read_size < PAGE_SIZE */
2596 else { /* read Size >= PAGE_SIZE */
2597
2598 #ifdef DEBUGMSG
2599 printk(KERN_INFO "%s: %s() Begin build claw read free chain \n",
2600 dev->name,__FUNCTION__);
2601 #endif
2602 for (i=0 ; i< privptr->p_env->read_buffers ; i++) {
2603 p_buff = (void *)__get_free_pages(__GFP_DMA,
2604 (int)pages_to_order_of_mag(privptr->p_buff_pages_perread) );
2605 if (p_buff==NULL) {
2606 printk(KERN_INFO "%s: %s() __get_free_pages for read "
2607 "buf failed : get is for %d pages\n",
2608 dev->name,__FUNCTION__,
2609 privptr->p_buff_pages_perread );
2610 free_pages((unsigned long)privptr->p_buff_ccw,
2611 (int)pages_to_order_of_mag(privptr->p_buff_ccw_num));
2612 /* free the write pages */
2613 p_buf=privptr->p_buff_write;
2614 while (p_buf!=NULL) {
2615 free_pages((unsigned long)p_buf->p_buffer,
2616 (int)pages_to_order_of_mag(
2617 privptr->p_buff_pages_perwrite ));
2618 p_buf=p_buf->next;
2619 }
2620 /* free any read pages already alloc */
2621 p_buf=privptr->p_buff_read;
2622 while (p_buf!=NULL) {
2623 free_pages((unsigned long)p_buf->p_buffer,
2624 (int)pages_to_order_of_mag(
2625 privptr->p_buff_pages_perread ));
2626 p_buf=p_buf->next;
2627 }
2628 privptr->p_buff_ccw=NULL;
2629 privptr->p_buff_write=NULL;
2630 #ifdef FUNCTRACE
2631 printk(KERN_INFO "%s: %s() exit on line %d, rc = ENOMEM\n",
2632 dev->name,__FUNCTION__,
2633 __LINE__);
2634 #endif
2635 return -ENOMEM;
2636 }
2637 memset(p_buff, 0x00, privptr->p_env->read_size);
2638 p_buf = p_free_chain;
2639 privptr->p_buff_read = p_buf;
2640 p_free_chain = p_buf->next;
2641
2642 if (p_last_CCWB==NULL) {
2643 p_buf->next=NULL;
2644 real_TIC_address=0;
2645 p_last_CCWB=p_buf;
2646 }
2647 else {
2648 p_buf->next=p_first_CCWB;
2649 real_TIC_address=
2650 (addr_t)__pa(
2651 &p_first_CCWB -> read );
2652 }
2653
2654 p_first_CCWB=p_buf;
2655 /* save buff address */
2656 p_buf->p_buffer=(struct clawbuf *)p_buff;
2657 /* initialize read command */
2658 p_buf-> read.cmd_code = CCW_CLAW_CMD_READ;
2659 p_buf-> read.cda = (__u32)__pa(p_buff);
2660 p_buf-> read.flags = CCW_FLAG_SLI | CCW_FLAG_CC;
2661 p_buf-> read.count = privptr->p_env->read_size;
2662
2663 /* initialize read_h command */
2664 p_buf-> read_h.cmd_code = CCW_CLAW_CMD_READHEADER;
2665 p_buf-> read_h.cda =
2666 (__u32)__pa(&(p_buf->header));
2667 p_buf-> read_h.flags = CCW_FLAG_SLI | CCW_FLAG_CC;
2668 p_buf-> read_h.count = sizeof(struct clawh);
2669
2670 /* initialize Signal command */
2671 p_buf-> signal.cmd_code = CCW_CLAW_CMD_SIGNAL_SMOD;
2672 p_buf-> signal.cda =
2673 (__u32)__pa(&(pClawH->flag));
2674 p_buf-> signal.flags = CCW_FLAG_SLI | CCW_FLAG_CC;
2675 p_buf-> signal.count = 1;
2676
2677 /* initialize r_TIC_1 command */
2678 p_buf-> r_TIC_1.cmd_code = CCW_CLAW_CMD_TIC;
2679 p_buf-> r_TIC_1.cda = (__u32)real_TIC_address;
2680 p_buf-> r_TIC_1.flags = 0;
2681 p_buf-> r_TIC_1.count = 0;
2682
2683 /* initialize r_read_FF command */
2684 p_buf-> r_read_FF.cmd_code = CCW_CLAW_CMD_READFF;
2685 p_buf-> r_read_FF.cda =
2686 (__u32)__pa(&(pClawH->flag));
2687 p_buf-> r_read_FF.flags =
2688 CCW_FLAG_SLI | CCW_FLAG_CC | CCW_FLAG_PCI;
2689 p_buf-> r_read_FF.count = 1;
2690
2691 /* initialize r_TIC_2 */
2692 memcpy(&p_buf->r_TIC_2, &p_buf->r_TIC_1,
2693 sizeof(struct ccw1));
2694
2695 /* initialize Header */
2696 p_buf->header.length=0xffff;
2697 p_buf->header.opcode=0xff;
2698 p_buf->header.flag=CLAW_PENDING;
2699
2700 } /* For read_buffers */
2701 } /* read_size >= PAGE_SIZE */
2702 } /* pBuffread = NULL */
2703 #ifdef DEBUGMSG
2704 printk(KERN_INFO "%s: %s() > End build claw read free chain \n",
2705 dev->name,__FUNCTION__);
2706 p_buf=p_first_CCWB;
2707 while (p_buf!=NULL) {
2708 dumpit((char *)p_buf, sizeof(struct ccwbk));
2709 p_buf=p_buf->next;
2710 }
2711
2712 #endif
2713 add_claw_reads( dev ,p_first_CCWB , p_last_CCWB);
2714 privptr->buffs_alloc = 1;
2715 #ifdef FUNCTRACE
2716 printk(KERN_INFO "%s: %s() exit on line %d\n",
2717 dev->name,__FUNCTION__,__LINE__);
2718 #endif
2719 return 0;
2720 } /* end of init_ccw_bk */
2721
2722 /*-------------------------------------------------------------------*
2723 * *
2724 * probe_error *
2725 * *
2726 *--------------------------------------------------------------------*/
2727
2728 static void
2729 probe_error( struct ccwgroup_device *cgdev)
2730 {
2731 struct claw_privbk *privptr;
2732 #ifdef FUNCTRACE
2733 printk(KERN_INFO "%s enter \n",__FUNCTION__);
2734 #endif
2735 CLAW_DBF_TEXT(4,trace,"proberr");
2736 #ifdef DEBUGMSG
2737 printk(KERN_INFO "%s variable cgdev =\n",__FUNCTION__);
2738 dumpit((char *) cgdev, sizeof(struct ccwgroup_device));
2739 #endif
2740 privptr=(struct claw_privbk *)cgdev->dev.driver_data;
2741 if (privptr!=NULL) {
2742 kfree(privptr->p_env);
2743 privptr->p_env=NULL;
2744 kfree(privptr->p_mtc_envelope);
2745 privptr->p_mtc_envelope=NULL;
2746 kfree(privptr);
2747 privptr=NULL;
2748 }
2749 #ifdef FUNCTRACE
2750 printk(KERN_INFO "%s > exit on line %d\n",
2751 __FUNCTION__,__LINE__);
2752 #endif
2753
2754 return;
2755 } /* probe_error */
2756
2757
2758
2759 /*-------------------------------------------------------------------*
2760 * claw_process_control *
2761 * *
2762 * *
2763 *--------------------------------------------------------------------*/
2764
2765 static int
2766 claw_process_control( struct net_device *dev, struct ccwbk * p_ccw)
2767 {
2768
2769 struct clawbuf *p_buf;
2770 struct clawctl ctlbk;
2771 struct clawctl *p_ctlbk;
2772 char temp_host_name[8];
2773 char temp_ws_name[8];
2774 struct claw_privbk *privptr;
2775 struct claw_env *p_env;
2776 struct sysval *p_sysval;
2777 struct conncmd *p_connect=NULL;
2778 int rc;
2779 struct chbk *p_ch = NULL;
2780 #ifdef FUNCTRACE
2781 printk(KERN_INFO "%s: %s() > enter \n",
2782 dev->name,__FUNCTION__);
2783 #endif
2784 CLAW_DBF_TEXT(2,setup,"clw_cntl");
2785 #ifdef DEBUGMSG
2786 printk(KERN_INFO "%s: variable dev =\n",dev->name);
2787 dumpit((char *) dev, sizeof(struct net_device));
2788 printk(KERN_INFO "%s: variable p_ccw =\n",dev->name);
2789 dumpit((char *) p_ccw, sizeof(struct ccwbk *));
2790 #endif
2791 udelay(1000); /* Wait a ms for the control packets to
2792 *catch up to each other */
2793 privptr=dev->priv;
2794 p_env=privptr->p_env;
2795 memcpy( &temp_host_name, p_env->host_name, 8);
2796 memcpy( &temp_ws_name, p_env->adapter_name , 8);
2797 printk(KERN_INFO "%s: CLAW device %.8s: "
2798 "Received Control Packet\n",
2799 dev->name, temp_ws_name);
2800 if (privptr->release_pend==1) {
2801 #ifdef FUNCTRACE
2802 printk(KERN_INFO "%s: %s() > "
2803 "exit on line %d, rc=0\n",
2804 dev->name,__FUNCTION__,__LINE__);
2805 #endif
2806 return 0;
2807 }
2808 p_buf=p_ccw->p_buffer;
2809 p_ctlbk=&ctlbk;
2810 if (p_env->packing == DO_PACKED) { /* packing in progress?*/
2811 memcpy(p_ctlbk, &p_buf->buffer[4], sizeof(struct clawctl));
2812 } else {
2813 memcpy(p_ctlbk, p_buf, sizeof(struct clawctl));
2814 }
2815 #ifdef IOTRACE
2816 printk(KERN_INFO "%s: dump claw control data inbound\n",dev->name);
2817 dumpit((char *)p_ctlbk, sizeof(struct clawctl));
2818 #endif
2819 switch (p_ctlbk->command)
2820 {
2821 case SYSTEM_VALIDATE_REQUEST:
2822 if (p_ctlbk->version!=CLAW_VERSION_ID) {
2823 claw_snd_sys_validate_rsp(dev, p_ctlbk,
2824 CLAW_RC_WRONG_VERSION );
2825 printk("%s: %d is wrong version id. "
2826 "Expected %d\n",
2827 dev->name, p_ctlbk->version,
2828 CLAW_VERSION_ID);
2829 }
2830 p_sysval=(struct sysval *)&(p_ctlbk->data);
2831 printk( "%s: Recv Sys Validate Request: "
2832 "Vers=%d,link_id=%d,Corr=%d,WS name=%."
2833 "8s,Host name=%.8s\n",
2834 dev->name, p_ctlbk->version,
2835 p_ctlbk->linkid,
2836 p_ctlbk->correlator,
2837 p_sysval->WS_name,
2838 p_sysval->host_name);
2839 if (0!=memcmp(temp_host_name,p_sysval->host_name,8)) {
2840 claw_snd_sys_validate_rsp(dev, p_ctlbk,
2841 CLAW_RC_NAME_MISMATCH );
2842 CLAW_DBF_TEXT(2,setup,"HSTBAD");
2843 CLAW_DBF_TEXT_(2,setup,"%s",p_sysval->host_name);
2844 CLAW_DBF_TEXT_(2,setup,"%s",temp_host_name);
2845 printk(KERN_INFO "%s: Host name mismatch\n",
2846 dev->name);
2847 printk(KERN_INFO "%s: Received :%s: "
2848 "expected :%s: \n",
2849 dev->name,
2850 p_sysval->host_name,
2851 temp_host_name);
2852 }
2853 if (0!=memcmp(temp_ws_name,p_sysval->WS_name,8)) {
2854 claw_snd_sys_validate_rsp(dev, p_ctlbk,
2855 CLAW_RC_NAME_MISMATCH );
2856 CLAW_DBF_TEXT(2,setup,"WSNBAD");
2857 CLAW_DBF_TEXT_(2,setup,"%s",p_sysval->WS_name);
2858 CLAW_DBF_TEXT_(2,setup,"%s",temp_ws_name);
2859 printk(KERN_INFO "%s: WS name mismatch\n",
2860 dev->name);
2861 printk(KERN_INFO "%s: Received :%s: "
2862 "expected :%s: \n",
2863 dev->name,
2864 p_sysval->WS_name,
2865 temp_ws_name);
2866 }
2867 if (( p_sysval->write_frame_size < p_env->write_size) &&
2868 ( p_env->packing == 0)) {
2869 claw_snd_sys_validate_rsp(dev, p_ctlbk,
2870 CLAW_RC_HOST_RCV_TOO_SMALL );
2871 printk(KERN_INFO "%s: host write size is too "
2872 "small\n", dev->name);
2873 CLAW_DBF_TEXT(2,setup,"wrtszbad");
2874 }
2875 if (( p_sysval->read_frame_size < p_env->read_size) &&
2876 ( p_env->packing == 0)) {
2877 claw_snd_sys_validate_rsp(dev, p_ctlbk,
2878 CLAW_RC_HOST_RCV_TOO_SMALL );
2879 printk(KERN_INFO "%s: host read size is too "
2880 "small\n", dev->name);
2881 CLAW_DBF_TEXT(2,setup,"rdsizbad");
2882 }
2883 claw_snd_sys_validate_rsp(dev, p_ctlbk, 0 );
2884 printk("%s: CLAW device %.8s: System validate"
2885 " completed.\n",dev->name, temp_ws_name);
2886 printk("%s: sys Validate Rsize:%d Wsize:%d\n",dev->name,
2887 p_sysval->read_frame_size,p_sysval->write_frame_size);
2888 privptr->system_validate_comp=1;
2889 if(strncmp(p_env->api_type,WS_APPL_NAME_PACKED,6) == 0) {
2890 p_env->packing = PACKING_ASK;
2891 }
2892 claw_strt_conn_req(dev);
2893 break;
2894
2895 case SYSTEM_VALIDATE_RESPONSE:
2896 p_sysval=(struct sysval *)&(p_ctlbk->data);
2897 printk("%s: Recv Sys Validate Resp: Vers=%d,Corr=%d,RC=%d,"
2898 "WS name=%.8s,Host name=%.8s\n",
2899 dev->name,
2900 p_ctlbk->version,
2901 p_ctlbk->correlator,
2902 p_ctlbk->rc,
2903 p_sysval->WS_name,
2904 p_sysval->host_name);
2905 switch (p_ctlbk->rc)
2906 {
2907 case 0:
2908 printk(KERN_INFO "%s: CLAW device "
2909 "%.8s: System validate "
2910 "completed.\n",
2911 dev->name, temp_ws_name);
2912 if (privptr->system_validate_comp == 0)
2913 claw_strt_conn_req(dev);
2914 privptr->system_validate_comp=1;
2915 break;
2916 case CLAW_RC_NAME_MISMATCH:
2917 printk(KERN_INFO "%s: Sys Validate "
2918 "Resp : Host, WS name is "
2919 "mismatch\n",
2920 dev->name);
2921 break;
2922 case CLAW_RC_WRONG_VERSION:
2923 printk(KERN_INFO "%s: Sys Validate "
2924 "Resp : Wrong version\n",
2925 dev->name);
2926 break;
2927 case CLAW_RC_HOST_RCV_TOO_SMALL:
2928 printk(KERN_INFO "%s: Sys Validate "
2929 "Resp : bad frame size\n",
2930 dev->name);
2931 break;
2932 default:
2933 printk(KERN_INFO "%s: Sys Validate "
2934 "error code=%d \n",
2935 dev->name, p_ctlbk->rc );
2936 break;
2937 }
2938 break;
2939
2940 case CONNECTION_REQUEST:
2941 p_connect=(struct conncmd *)&(p_ctlbk->data);
2942 printk(KERN_INFO "%s: Recv Conn Req: Vers=%d,link_id=%d,"
2943 "Corr=%d,HOST appl=%.8s,WS appl=%.8s\n",
2944 dev->name,
2945 p_ctlbk->version,
2946 p_ctlbk->linkid,
2947 p_ctlbk->correlator,
2948 p_connect->host_name,
2949 p_connect->WS_name);
2950 if (privptr->active_link_ID!=0 ) {
2951 claw_snd_disc(dev, p_ctlbk);
2952 printk(KERN_INFO "%s: Conn Req error : "
2953 "already logical link is active \n",
2954 dev->name);
2955 }
2956 if (p_ctlbk->linkid!=1 ) {
2957 claw_snd_disc(dev, p_ctlbk);
2958 printk(KERN_INFO "%s: Conn Req error : "
2959 "req logical link id is not 1\n",
2960 dev->name);
2961 }
2962 rc=find_link(dev,
2963 p_connect->host_name, p_connect->WS_name);
2964 if (rc!=0) {
2965 claw_snd_disc(dev, p_ctlbk);
2966 printk(KERN_INFO "%s: Conn Req error : "
2967 "req appl name does not match\n",
2968 dev->name);
2969 }
2970 claw_send_control(dev,
2971 CONNECTION_CONFIRM, p_ctlbk->linkid,
2972 p_ctlbk->correlator,
2973 0, p_connect->host_name,
2974 p_connect->WS_name);
2975 if (p_env->packing == PACKING_ASK) {
2976 printk("%s: Now Pack ask\n",dev->name);
2977 p_env->packing = PACK_SEND;
2978 claw_snd_conn_req(dev,0);
2979 }
2980 printk(KERN_INFO "%s: CLAW device %.8s: Connection "
2981 "completed link_id=%d.\n",
2982 dev->name, temp_ws_name,
2983 p_ctlbk->linkid);
2984 privptr->active_link_ID=p_ctlbk->linkid;
2985 p_ch=&privptr->channel[WRITE];
2986 wake_up(&p_ch->wait); /* wake up claw_open ( WRITE) */
2987 break;
2988 case CONNECTION_RESPONSE:
2989 p_connect=(struct conncmd *)&(p_ctlbk->data);
2990 printk(KERN_INFO "%s: Revc Conn Resp: Vers=%d,link_id=%d,"
2991 "Corr=%d,RC=%d,Host appl=%.8s, WS appl=%.8s\n",
2992 dev->name,
2993 p_ctlbk->version,
2994 p_ctlbk->linkid,
2995 p_ctlbk->correlator,
2996 p_ctlbk->rc,
2997 p_connect->host_name,
2998 p_connect->WS_name);
2999
3000 if (p_ctlbk->rc !=0 ) {
3001 printk(KERN_INFO "%s: Conn Resp error: rc=%d \n",
3002 dev->name, p_ctlbk->rc);
3003 return 1;
3004 }
3005 rc=find_link(dev,
3006 p_connect->host_name, p_connect->WS_name);
3007 if (rc!=0) {
3008 claw_snd_disc(dev, p_ctlbk);
3009 printk(KERN_INFO "%s: Conn Resp error: "
3010 "req appl name does not match\n",
3011 dev->name);
3012 }
3013 /* should be until CONNECTION_CONFIRM */
3014 privptr->active_link_ID = - (p_ctlbk->linkid);
3015 break;
3016 case CONNECTION_CONFIRM:
3017 p_connect=(struct conncmd *)&(p_ctlbk->data);
3018 printk(KERN_INFO "%s: Recv Conn Confirm:Vers=%d,link_id=%d,"
3019 "Corr=%d,Host appl=%.8s,WS appl=%.8s\n",
3020 dev->name,
3021 p_ctlbk->version,
3022 p_ctlbk->linkid,
3023 p_ctlbk->correlator,
3024 p_connect->host_name,
3025 p_connect->WS_name);
3026 if (p_ctlbk->linkid== -(privptr->active_link_ID)) {
3027 privptr->active_link_ID=p_ctlbk->linkid;
3028 if (p_env->packing > PACKING_ASK) {
3029 printk(KERN_INFO "%s: Confirmed Now packing\n",dev->name);
3030 p_env->packing = DO_PACKED;
3031 }
3032 p_ch=&privptr->channel[WRITE];
3033 wake_up(&p_ch->wait);
3034 }
3035 else {
3036 printk(KERN_INFO "%s: Conn confirm: "
3037 "unexpected linkid=%d \n",
3038 dev->name, p_ctlbk->linkid);
3039 claw_snd_disc(dev, p_ctlbk);
3040 }
3041 break;
3042 case DISCONNECT:
3043 printk(KERN_INFO "%s: Disconnect: "
3044 "Vers=%d,link_id=%d,Corr=%d\n",
3045 dev->name, p_ctlbk->version,
3046 p_ctlbk->linkid, p_ctlbk->correlator);
3047 if ((p_ctlbk->linkid == 2) &&
3048 (p_env->packing == PACK_SEND)) {
3049 privptr->active_link_ID = 1;
3050 p_env->packing = DO_PACKED;
3051 }
3052 else
3053 privptr->active_link_ID=0;
3054 break;
3055 case CLAW_ERROR:
3056 printk(KERN_INFO "%s: CLAW ERROR detected\n",
3057 dev->name);
3058 break;
3059 default:
3060 printk(KERN_INFO "%s: Unexpected command code=%d \n",
3061 dev->name, p_ctlbk->command);
3062 break;
3063 }
3064
3065 #ifdef FUNCTRACE
3066 printk(KERN_INFO "%s: %s() exit on line %d, rc = 0\n",
3067 dev->name,__FUNCTION__,__LINE__);
3068 #endif
3069
3070 return 0;
3071 } /* end of claw_process_control */
3072
3073
3074 /*-------------------------------------------------------------------*
3075 * claw_send_control *
3076 * *
3077 *--------------------------------------------------------------------*/
3078
3079 static int
3080 claw_send_control(struct net_device *dev, __u8 type, __u8 link,
3081 __u8 correlator, __u8 rc, char *local_name, char *remote_name)
3082 {
3083 struct claw_privbk *privptr;
3084 struct clawctl *p_ctl;
3085 struct sysval *p_sysval;
3086 struct conncmd *p_connect;
3087 struct sk_buff *skb;
3088
3089 #ifdef FUNCTRACE
3090 printk(KERN_INFO "%s:%s > enter \n",dev->name,__FUNCTION__);
3091 #endif
3092 CLAW_DBF_TEXT(2,setup,"sndcntl");
3093 #ifdef DEBUGMSG
3094 printk(KERN_INFO "%s: Sending Control Packet \n",dev->name);
3095 printk(KERN_INFO "%s: variable type = 0x%X, link = "
3096 "%d, correlator = %d, rc = %d\n",
3097 dev->name,type, link, correlator, rc);
3098 printk(KERN_INFO "%s: variable local_name = %s, "
3099 "remote_name = %s\n",dev->name, local_name, remote_name);
3100 #endif
3101 privptr=dev->priv;
3102 p_ctl=(struct clawctl *)&privptr->ctl_bk;
3103
3104 p_ctl->command=type;
3105 p_ctl->version=CLAW_VERSION_ID;
3106 p_ctl->linkid=link;
3107 p_ctl->correlator=correlator;
3108 p_ctl->rc=rc;
3109
3110 p_sysval=(struct sysval *)&p_ctl->data;
3111 p_connect=(struct conncmd *)&p_ctl->data;
3112
3113 switch (p_ctl->command) {
3114 case SYSTEM_VALIDATE_REQUEST:
3115 case SYSTEM_VALIDATE_RESPONSE:
3116 memcpy(&p_sysval->host_name, local_name, 8);
3117 memcpy(&p_sysval->WS_name, remote_name, 8);
3118 if (privptr->p_env->packing > 0) {
3119 p_sysval->read_frame_size=DEF_PACK_BUFSIZE;
3120 p_sysval->write_frame_size=DEF_PACK_BUFSIZE;
3121 } else {
3122 /* how big is the piggest group of packets */
3123 p_sysval->read_frame_size=privptr->p_env->read_size;
3124 p_sysval->write_frame_size=privptr->p_env->write_size;
3125 }
3126 memset(&p_sysval->reserved, 0x00, 4);
3127 break;
3128 case CONNECTION_REQUEST:
3129 case CONNECTION_RESPONSE:
3130 case CONNECTION_CONFIRM:
3131 case DISCONNECT:
3132 memcpy(&p_sysval->host_name, local_name, 8);
3133 memcpy(&p_sysval->WS_name, remote_name, 8);
3134 if (privptr->p_env->packing > 0) {
3135 /* How big is the biggest packet */
3136 p_connect->reserved1[0]=CLAW_FRAME_SIZE;
3137 p_connect->reserved1[1]=CLAW_FRAME_SIZE;
3138 } else {
3139 memset(&p_connect->reserved1, 0x00, 4);
3140 memset(&p_connect->reserved2, 0x00, 4);
3141 }
3142 break;
3143 default:
3144 break;
3145 }
3146
3147 /* write Control Record to the device */
3148
3149
3150 skb = dev_alloc_skb(sizeof(struct clawctl));
3151 if (!skb) {
3152 printk( "%s:%s low on mem, returning...\n",
3153 dev->name,__FUNCTION__);
3154 #ifdef DEBUG
3155 printk(KERN_INFO "%s:%s Exit, rc = ENOMEM\n",
3156 dev->name,__FUNCTION__);
3157 #endif
3158 return -ENOMEM;
3159 }
3160 memcpy(skb_put(skb, sizeof(struct clawctl)),
3161 p_ctl, sizeof(struct clawctl));
3162 #ifdef IOTRACE
3163 printk(KERN_INFO "%s: outbnd claw cntl data \n",dev->name);
3164 dumpit((char *)p_ctl,sizeof(struct clawctl));
3165 #endif
3166 if (privptr->p_env->packing >= PACK_SEND)
3167 claw_hw_tx(skb, dev, 1);
3168 else
3169 claw_hw_tx(skb, dev, 0);
3170 #ifdef FUNCTRACE
3171 printk(KERN_INFO "%s:%s Exit on line %d\n",
3172 dev->name,__FUNCTION__,__LINE__);
3173 #endif
3174
3175 return 0;
3176 } /* end of claw_send_control */
3177
3178 /*-------------------------------------------------------------------*
3179 * claw_snd_conn_req *
3180 * *
3181 *--------------------------------------------------------------------*/
3182 static int
3183 claw_snd_conn_req(struct net_device *dev, __u8 link)
3184 {
3185 int rc;
3186 struct claw_privbk *privptr=dev->priv;
3187 struct clawctl *p_ctl;
3188
3189 #ifdef FUNCTRACE
3190 printk(KERN_INFO "%s:%s Enter \n",dev->name,__FUNCTION__);
3191 #endif
3192 CLAW_DBF_TEXT(2,setup,"snd_conn");
3193 #ifdef DEBUGMSG
3194 printk(KERN_INFO "%s: variable link = %X, dev =\n",dev->name, link);
3195 dumpit((char *) dev, sizeof(struct net_device));
3196 #endif
3197 rc = 1;
3198 p_ctl=(struct clawctl *)&privptr->ctl_bk;
3199 p_ctl->linkid = link;
3200 if ( privptr->system_validate_comp==0x00 ) {
3201 #ifdef FUNCTRACE
3202 printk(KERN_INFO "%s:%s Exit on line %d, rc = 1\n",
3203 dev->name,__FUNCTION__,__LINE__);
3204 #endif
3205 return rc;
3206 }
3207 if (privptr->p_env->packing == PACKING_ASK )
3208 rc=claw_send_control(dev, CONNECTION_REQUEST,0,0,0,
3209 WS_APPL_NAME_PACKED, WS_APPL_NAME_PACKED);
3210 if (privptr->p_env->packing == PACK_SEND) {
3211 rc=claw_send_control(dev, CONNECTION_REQUEST,0,0,0,
3212 WS_APPL_NAME_IP_NAME, WS_APPL_NAME_IP_NAME);
3213 }
3214 if (privptr->p_env->packing == 0)
3215 rc=claw_send_control(dev, CONNECTION_REQUEST,0,0,0,
3216 HOST_APPL_NAME, privptr->p_env->api_type);
3217 #ifdef FUNCTRACE
3218 printk(KERN_INFO "%s:%s Exit on line %d, rc = %d\n",
3219 dev->name,__FUNCTION__,__LINE__, rc);
3220 #endif
3221 return rc;
3222
3223 } /* end of claw_snd_conn_req */
3224
3225
3226 /*-------------------------------------------------------------------*
3227 * claw_snd_disc *
3228 * *
3229 *--------------------------------------------------------------------*/
3230
3231 static int
3232 claw_snd_disc(struct net_device *dev, struct clawctl * p_ctl)
3233 {
3234 int rc;
3235 struct conncmd * p_connect;
3236
3237 #ifdef FUNCTRACE
3238 printk(KERN_INFO "%s:%s Enter\n",dev->name,__FUNCTION__);
3239 #endif
3240 CLAW_DBF_TEXT(2,setup,"snd_dsc");
3241 #ifdef DEBUGMSG
3242 printk(KERN_INFO "%s: variable dev =\n",dev->name);
3243 dumpit((char *) dev, sizeof(struct net_device));
3244 printk(KERN_INFO "%s: variable p_ctl",dev->name);
3245 dumpit((char *) p_ctl, sizeof(struct clawctl));
3246 #endif
3247 p_connect=(struct conncmd *)&p_ctl->data;
3248
3249 rc=claw_send_control(dev, DISCONNECT, p_ctl->linkid,
3250 p_ctl->correlator, 0,
3251 p_connect->host_name, p_connect->WS_name);
3252 #ifdef FUNCTRACE
3253 printk(KERN_INFO "%s:%s Exit on line %d, rc = %d\n",
3254 dev->name,__FUNCTION__, __LINE__, rc);
3255 #endif
3256 return rc;
3257 } /* end of claw_snd_disc */
3258
3259
3260 /*-------------------------------------------------------------------*
3261 * claw_snd_sys_validate_rsp *
3262 * *
3263 *--------------------------------------------------------------------*/
3264
3265 static int
3266 claw_snd_sys_validate_rsp(struct net_device *dev,
3267 struct clawctl *p_ctl, __u32 return_code)
3268 {
3269 struct claw_env * p_env;
3270 struct claw_privbk *privptr;
3271 int rc;
3272
3273 #ifdef FUNCTRACE
3274 printk(KERN_INFO "%s:%s Enter\n",
3275 dev->name,__FUNCTION__);
3276 #endif
3277 CLAW_DBF_TEXT(2,setup,"chkresp");
3278 #ifdef DEBUGMSG
3279 printk(KERN_INFO "%s: variable return_code = %d, dev =\n",
3280 dev->name, return_code);
3281 dumpit((char *) dev, sizeof(struct net_device));
3282 printk(KERN_INFO "%s: variable p_ctl =\n",dev->name);
3283 dumpit((char *) p_ctl, sizeof(struct clawctl));
3284 #endif
3285 privptr = dev->priv;
3286 p_env=privptr->p_env;
3287 rc=claw_send_control(dev, SYSTEM_VALIDATE_RESPONSE,
3288 p_ctl->linkid,
3289 p_ctl->correlator,
3290 return_code,
3291 p_env->host_name,
3292 p_env->adapter_name );
3293 #ifdef FUNCTRACE
3294 printk(KERN_INFO "%s:%s Exit on line %d, rc = %d\n",
3295 dev->name,__FUNCTION__,__LINE__, rc);
3296 #endif
3297 return rc;
3298 } /* end of claw_snd_sys_validate_rsp */
3299
3300 /*-------------------------------------------------------------------*
3301 * claw_strt_conn_req *
3302 * *
3303 *--------------------------------------------------------------------*/
3304
3305 static int
3306 claw_strt_conn_req(struct net_device *dev )
3307 {
3308 int rc;
3309
3310 #ifdef FUNCTRACE
3311 printk(KERN_INFO "%s:%s Enter\n",dev->name,__FUNCTION__);
3312 #endif
3313 CLAW_DBF_TEXT(2,setup,"conn_req");
3314 #ifdef DEBUGMSG
3315 printk(KERN_INFO "%s: variable dev =\n",dev->name);
3316 dumpit((char *) dev, sizeof(struct net_device));
3317 #endif
3318 rc=claw_snd_conn_req(dev, 1);
3319 #ifdef FUNCTRACE
3320 printk(KERN_INFO "%s:%s Exit on line %d, rc = %d\n",
3321 dev->name,__FUNCTION__,__LINE__, rc);
3322 #endif
3323 return rc;
3324 } /* end of claw_strt_conn_req */
3325
3326
3327
3328 /*-------------------------------------------------------------------*
3329 * claw_stats *
3330 *-------------------------------------------------------------------*/
3331
3332 static struct
3333 net_device_stats *claw_stats(struct net_device *dev)
3334 {
3335 struct claw_privbk *privptr;
3336 #ifdef FUNCTRACE
3337 printk(KERN_INFO "%s:%s Enter\n",dev->name,__FUNCTION__);
3338 #endif
3339 CLAW_DBF_TEXT(4,trace,"stats");
3340 privptr = dev->priv;
3341 #ifdef FUNCTRACE
3342 printk(KERN_INFO "%s:%s Exit on line %d\n",
3343 dev->name,__FUNCTION__,__LINE__);
3344 #endif
3345 return &privptr->stats;
3346 } /* end of claw_stats */
3347
3348
3349 /*-------------------------------------------------------------------*
3350 * unpack_read *
3351 * *
3352 *--------------------------------------------------------------------*/
3353 static void
3354 unpack_read(struct net_device *dev )
3355 {
3356 struct sk_buff *skb;
3357 struct claw_privbk *privptr;
3358 struct claw_env *p_env;
3359 struct ccwbk *p_this_ccw;
3360 struct ccwbk *p_first_ccw;
3361 struct ccwbk *p_last_ccw;
3362 struct clawph *p_packh;
3363 void *p_packd;
3364 struct clawctl *p_ctlrec=NULL;
3365
3366 __u32 len_of_data;
3367 __u32 pack_off;
3368 __u8 link_num;
3369 __u8 mtc_this_frm=0;
3370 __u32 bytes_to_mov;
3371 struct chbk *p_ch = NULL;
3372 int i=0;
3373 int p=0;
3374
3375 #ifdef FUNCTRACE
3376 printk(KERN_INFO "%s:%s enter \n",dev->name,__FUNCTION__);
3377 #endif
3378 CLAW_DBF_TEXT(4,trace,"unpkread");
3379 p_first_ccw=NULL;
3380 p_last_ccw=NULL;
3381 p_packh=NULL;
3382 p_packd=NULL;
3383 privptr=dev->priv;
3384 p_env = privptr->p_env;
3385 p_this_ccw=privptr->p_read_active_first;
3386 i=0;
3387 while (p_this_ccw!=NULL && p_this_ccw->header.flag!=CLAW_PENDING) {
3388 #ifdef IOTRACE
3389 printk(KERN_INFO "%s p_this_ccw \n",dev->name);
3390 dumpit((char*)p_this_ccw, sizeof(struct ccwbk));
3391 printk(KERN_INFO "%s Inbound p_this_ccw->p_buffer(64)"
3392 " pk=%d \n",dev->name,p_env->packing);
3393 dumpit((char *)p_this_ccw->p_buffer, 64 );
3394 #endif
3395 pack_off = 0;
3396 p = 0;
3397 p_this_ccw->header.flag=CLAW_PENDING;
3398 privptr->p_read_active_first=p_this_ccw->next;
3399 p_this_ccw->next=NULL;
3400 p_packh = (struct clawph *)p_this_ccw->p_buffer;
3401 if ((p_env->packing == PACK_SEND) &&
3402 (p_packh->len == 32) &&
3403 (p_packh->link_num == 0)) { /* is it a packed ctl rec? */
3404 p_packh++; /* peek past pack header */
3405 p_ctlrec = (struct clawctl *)p_packh;
3406 p_packh--; /* un peek */
3407 if ((p_ctlrec->command == CONNECTION_RESPONSE) ||
3408 (p_ctlrec->command == CONNECTION_CONFIRM))
3409 p_env->packing = DO_PACKED;
3410 }
3411 if (p_env->packing == DO_PACKED)
3412 link_num=p_packh->link_num;
3413 else
3414 link_num=p_this_ccw->header.opcode / 8;
3415 if ((p_this_ccw->header.opcode & MORE_to_COME_FLAG)!=0) {
3416 #ifdef DEBUGMSG
3417 printk(KERN_INFO "%s: %s > More_to_come is ON\n",
3418 dev->name,__FUNCTION__);
3419 #endif
3420 mtc_this_frm=1;
3421 if (p_this_ccw->header.length!=
3422 privptr->p_env->read_size ) {
3423 printk(KERN_INFO " %s: Invalid frame detected "
3424 "length is %02x\n" ,
3425 dev->name, p_this_ccw->header.length);
3426 }
3427 }
3428
3429 if (privptr->mtc_skipping) {
3430 /*
3431 * We're in the mode of skipping past a
3432 * multi-frame message
3433 * that we can't process for some reason or other.
3434 * The first frame without the More-To-Come flag is
3435 * the last frame of the skipped message.
3436 */
3437 /* in case of More-To-Come not set in this frame */
3438 if (mtc_this_frm==0) {
3439 privptr->mtc_skipping=0; /* Ok, the end */
3440 privptr->mtc_logical_link=-1;
3441 }
3442 #ifdef DEBUGMSG
3443 printk(KERN_INFO "%s:%s goto next "
3444 "frame from MoretoComeSkip \n",
3445 dev->name,__FUNCTION__);
3446 #endif
3447 goto NextFrame;
3448 }
3449
3450 if (link_num==0) {
3451 claw_process_control(dev, p_this_ccw);
3452 #ifdef DEBUGMSG
3453 printk(KERN_INFO "%s:%s goto next "
3454 "frame from claw_process_control \n",
3455 dev->name,__FUNCTION__);
3456 #endif
3457 CLAW_DBF_TEXT(4,trace,"UnpkCntl");
3458 goto NextFrame;
3459 }
3460 unpack_next:
3461 if (p_env->packing == DO_PACKED) {
3462 if (pack_off > p_env->read_size)
3463 goto NextFrame;
3464 p_packd = p_this_ccw->p_buffer+pack_off;
3465 p_packh = (struct clawph *) p_packd;
3466 if ((p_packh->len == 0) || /* all done with this frame? */
3467 (p_packh->flag != 0))
3468 goto NextFrame;
3469 bytes_to_mov = p_packh->len;
3470 pack_off += bytes_to_mov+sizeof(struct clawph);
3471 p++;
3472 } else {
3473 bytes_to_mov=p_this_ccw->header.length;
3474 }
3475 if (privptr->mtc_logical_link<0) {
3476 #ifdef DEBUGMSG
3477 printk(KERN_INFO "%s: %s mtc_logical_link < 0 \n",
3478 dev->name,__FUNCTION__);
3479 #endif
3480
3481 /*
3482 * if More-To-Come is set in this frame then we don't know
3483 * length of entire message, and hence have to allocate
3484 * large buffer */
3485
3486 /* We are starting a new envelope */
3487 privptr->mtc_offset=0;
3488 privptr->mtc_logical_link=link_num;
3489 }
3490
3491 if (bytes_to_mov > (MAX_ENVELOPE_SIZE- privptr->mtc_offset) ) {
3492 /* error */
3493 #ifdef DEBUGMSG
3494 printk(KERN_INFO "%s: %s > goto next "
3495 "frame from MoretoComeSkip \n",
3496 dev->name,
3497 __FUNCTION__);
3498 printk(KERN_INFO " bytes_to_mov %d > (MAX_ENVELOPE_"
3499 "SIZE-privptr->mtc_offset %d)\n",
3500 bytes_to_mov,(MAX_ENVELOPE_SIZE- privptr->mtc_offset));
3501 #endif
3502 privptr->stats.rx_frame_errors++;
3503 goto NextFrame;
3504 }
3505 if (p_env->packing == DO_PACKED) {
3506 memcpy( privptr->p_mtc_envelope+ privptr->mtc_offset,
3507 p_packd+sizeof(struct clawph), bytes_to_mov);
3508
3509 } else {
3510 memcpy( privptr->p_mtc_envelope+ privptr->mtc_offset,
3511 p_this_ccw->p_buffer, bytes_to_mov);
3512 }
3513 #ifdef DEBUGMSG
3514 printk(KERN_INFO "%s: %s() received data \n",
3515 dev->name,__FUNCTION__);
3516 if (p_env->packing == DO_PACKED)
3517 dumpit((char *)p_packd+sizeof(struct clawph),32);
3518 else
3519 dumpit((char *)p_this_ccw->p_buffer, 32);
3520 printk(KERN_INFO "%s: %s() bytelength %d \n",
3521 dev->name,__FUNCTION__,bytes_to_mov);
3522 #endif
3523 if (mtc_this_frm==0) {
3524 len_of_data=privptr->mtc_offset+bytes_to_mov;
3525 skb=dev_alloc_skb(len_of_data);
3526 if (skb) {
3527 memcpy(skb_put(skb,len_of_data),
3528 privptr->p_mtc_envelope,
3529 len_of_data);
3530 skb->mac.raw=skb->data;
3531 skb->dev=dev;
3532 skb->protocol=htons(ETH_P_IP);
3533 skb->ip_summed=CHECKSUM_UNNECESSARY;
3534 privptr->stats.rx_packets++;
3535 privptr->stats.rx_bytes+=len_of_data;
3536 netif_rx(skb);
3537 #ifdef DEBUGMSG
3538 printk(KERN_INFO "%s: %s() netif_"
3539 "rx(skb) completed \n",
3540 dev->name,__FUNCTION__);
3541 #endif
3542 }
3543 else {
3544 privptr->stats.rx_dropped++;
3545 printk(KERN_WARNING "%s: %s() low on memory\n",
3546 dev->name,__FUNCTION__);
3547 }
3548 privptr->mtc_offset=0;
3549 privptr->mtc_logical_link=-1;
3550 }
3551 else {
3552 privptr->mtc_offset+=bytes_to_mov;
3553 }
3554 if (p_env->packing == DO_PACKED)
3555 goto unpack_next;
3556 NextFrame:
3557 /*
3558 * Remove ThisCCWblock from active read queue, and add it
3559 * to queue of free blocks to be reused.
3560 */
3561 i++;
3562 p_this_ccw->header.length=0xffff;
3563 p_this_ccw->header.opcode=0xff;
3564 /*
3565 * add this one to the free queue for later reuse
3566 */
3567 if (p_first_ccw==NULL) {
3568 p_first_ccw = p_this_ccw;
3569 }
3570 else {
3571 p_last_ccw->next = p_this_ccw;
3572 }
3573 p_last_ccw = p_this_ccw;
3574 /*
3575 * chain to next block on active read queue
3576 */
3577 p_this_ccw = privptr->p_read_active_first;
3578 CLAW_DBF_TEXT_(4,trace,"rxpkt %d",p);
3579 } /* end of while */
3580
3581 /* check validity */
3582
3583 #ifdef IOTRACE
3584 printk(KERN_INFO "%s:%s processed frame is %d \n",
3585 dev->name,__FUNCTION__,i);
3586 printk(KERN_INFO "%s:%s F:%lx L:%lx\n",
3587 dev->name,
3588 __FUNCTION__,
3589 (unsigned long)p_first_ccw,
3590 (unsigned long)p_last_ccw);
3591 #endif
3592 CLAW_DBF_TEXT_(4,trace,"rxfrm %d",i);
3593 add_claw_reads(dev, p_first_ccw, p_last_ccw);
3594 p_ch=&privptr->channel[READ];
3595 claw_strt_read(dev, LOCK_YES);
3596 #ifdef FUNCTRACE
3597 printk(KERN_INFO "%s: %s exit on line %d\n",
3598 dev->name, __FUNCTION__, __LINE__);
3599 #endif
3600 return;
3601 } /* end of unpack_read */
3602
3603 /*-------------------------------------------------------------------*
3604 * claw_strt_read *
3605 * *
3606 *--------------------------------------------------------------------*/
3607 static void
3608 claw_strt_read (struct net_device *dev, int lock )
3609 {
3610 int rc = 0;
3611 __u32 parm;
3612 unsigned long saveflags = 0;
3613 struct claw_privbk *privptr=dev->priv;
3614 struct ccwbk*p_ccwbk;
3615 struct chbk *p_ch;
3616 struct clawh *p_clawh;
3617 p_ch=&privptr->channel[READ];
3618
3619 #ifdef FUNCTRACE
3620 printk(KERN_INFO "%s:%s Enter \n",dev->name,__FUNCTION__);
3621 printk(KERN_INFO "%s: variable lock = %d, dev =\n",dev->name, lock);
3622 dumpit((char *) dev, sizeof(struct net_device));
3623 #endif
3624 CLAW_DBF_TEXT(4,trace,"StRdNter");
3625 p_clawh=(struct clawh *)privptr->p_claw_signal_blk;
3626 p_clawh->flag=CLAW_IDLE; /* 0x00 */
3627
3628 if ((privptr->p_write_active_first!=NULL &&
3629 privptr->p_write_active_first->header.flag!=CLAW_PENDING) ||
3630 (privptr->p_read_active_first!=NULL &&
3631 privptr->p_read_active_first->header.flag!=CLAW_PENDING )) {
3632 p_clawh->flag=CLAW_BUSY; /* 0xff */
3633 }
3634 #ifdef DEBUGMSG
3635 printk(KERN_INFO "%s:%s state-%02x\n" ,
3636 dev->name,__FUNCTION__, p_ch->claw_state);
3637 #endif
3638 if (lock==LOCK_YES) {
3639 spin_lock_irqsave(get_ccwdev_lock(p_ch->cdev), saveflags);
3640 }
3641 if (test_and_set_bit(0, (void *)&p_ch->IO_active) == 0) {
3642 #ifdef DEBUGMSG
3643 printk(KERN_INFO "%s: HOT READ started in %s\n" ,
3644 dev->name,__FUNCTION__);
3645 p_clawh=(struct clawh *)privptr->p_claw_signal_blk;
3646 dumpit((char *)&p_clawh->flag , 1);
3647 #endif
3648 CLAW_DBF_TEXT(4,trace,"HotRead");
3649 p_ccwbk=privptr->p_read_active_first;
3650 parm = (unsigned long) p_ch;
3651 rc = ccw_device_start (p_ch->cdev, &p_ccwbk->read, parm,
3652 0xff, 0);
3653 if (rc != 0) {
3654 ccw_check_return_code(p_ch->cdev, rc);
3655 }
3656 }
3657 else {
3658 #ifdef DEBUGMSG
3659 printk(KERN_INFO "%s: No READ started by %s() In progress\n" ,
3660 dev->name,__FUNCTION__);
3661 #endif
3662 CLAW_DBF_TEXT(2,trace,"ReadAct");
3663 }
3664
3665 if (lock==LOCK_YES) {
3666 spin_unlock_irqrestore(get_ccwdev_lock(p_ch->cdev), saveflags);
3667 }
3668 #ifdef FUNCTRACE
3669 printk(KERN_INFO "%s:%s Exit on line %d\n",
3670 dev->name,__FUNCTION__,__LINE__);
3671 #endif
3672 CLAW_DBF_TEXT(4,trace,"StRdExit");
3673 return;
3674 } /* end of claw_strt_read */
3675
3676 /*-------------------------------------------------------------------*
3677 * claw_strt_out_IO *
3678 * *
3679 *--------------------------------------------------------------------*/
3680
3681 static void
3682 claw_strt_out_IO( struct net_device *dev )
3683 {
3684 int rc = 0;
3685 unsigned long parm;
3686 struct claw_privbk *privptr;
3687 struct chbk *p_ch;
3688 struct ccwbk *p_first_ccw;
3689
3690 #ifdef FUNCTRACE
3691 printk(KERN_INFO "%s:%s Enter\n",dev->name,__FUNCTION__);
3692 #endif
3693 if (!dev) {
3694 return;
3695 }
3696 privptr=(struct claw_privbk *)dev->priv;
3697 p_ch=&privptr->channel[WRITE];
3698
3699 #ifdef DEBUGMSG
3700 printk(KERN_INFO "%s:%s state-%02x\n" ,
3701 dev->name,__FUNCTION__,p_ch->claw_state);
3702 #endif
3703 CLAW_DBF_TEXT(4,trace,"strt_io");
3704 p_first_ccw=privptr->p_write_active_first;
3705
3706 if (p_ch->claw_state == CLAW_STOP)
3707 return;
3708 if (p_first_ccw == NULL) {
3709 #ifdef FUNCTRACE
3710 printk(KERN_INFO "%s:%s Exit on line %d\n",
3711 dev->name,__FUNCTION__,__LINE__);
3712 #endif
3713 return;
3714 }
3715 if (test_and_set_bit(0, (void *)&p_ch->IO_active) == 0) {
3716 parm = (unsigned long) p_ch;
3717 #ifdef DEBUGMSG
3718 printk(KERN_INFO "%s:%s do_io \n" ,dev->name,__FUNCTION__);
3719 dumpit((char *)p_first_ccw, sizeof(struct ccwbk));
3720 #endif
3721 CLAW_DBF_TEXT(2,trace,"StWrtIO");
3722 rc = ccw_device_start (p_ch->cdev,&p_first_ccw->write, parm,
3723 0xff, 0);
3724 if (rc != 0) {
3725 ccw_check_return_code(p_ch->cdev, rc);
3726 }
3727 }
3728 dev->trans_start = jiffies;
3729 #ifdef FUNCTRACE
3730 printk(KERN_INFO "%s:%s Exit on line %d\n",
3731 dev->name,__FUNCTION__,__LINE__);
3732 #endif
3733
3734 return;
3735 } /* end of claw_strt_out_IO */
3736
3737 /*-------------------------------------------------------------------*
3738 * Free write buffers *
3739 * *
3740 *--------------------------------------------------------------------*/
3741
3742 static void
3743 claw_free_wrt_buf( struct net_device *dev )
3744 {
3745
3746 struct claw_privbk *privptr=(struct claw_privbk *)dev->priv;
3747 struct ccwbk*p_first_ccw;
3748 struct ccwbk*p_last_ccw;
3749 struct ccwbk*p_this_ccw;
3750 struct ccwbk*p_next_ccw;
3751 #ifdef IOTRACE
3752 struct ccwbk*p_buf;
3753 #endif
3754 #ifdef FUNCTRACE
3755 printk(KERN_INFO "%s:%s Enter\n",dev->name,__FUNCTION__);
3756 printk(KERN_INFO "%s: free count = %d variable dev =\n",
3757 dev->name,privptr->write_free_count);
3758 #endif
3759 CLAW_DBF_TEXT(4,trace,"freewrtb");
3760 /* scan the write queue to free any completed write packets */
3761 p_first_ccw=NULL;
3762 p_last_ccw=NULL;
3763 #ifdef IOTRACE
3764 printk(KERN_INFO "%s: Dump current CCW chain \n",dev->name );
3765 p_buf=privptr->p_write_active_first;
3766 while (p_buf!=NULL) {
3767 dumpit((char *)p_buf, sizeof(struct ccwbk));
3768 p_buf=p_buf->next;
3769 }
3770 if (p_buf==NULL) {
3771 printk(KERN_INFO "%s: privptr->p_write_"
3772 "active_first==NULL\n",dev->name );
3773 }
3774 p_buf=(struct ccwbk*)privptr->p_end_ccw;
3775 dumpit((char *)p_buf, sizeof(struct endccw));
3776 #endif
3777 p_this_ccw=privptr->p_write_active_first;
3778 while ( (p_this_ccw!=NULL) && (p_this_ccw->header.flag!=CLAW_PENDING))
3779 {
3780 p_next_ccw = p_this_ccw->next;
3781 if (((p_next_ccw!=NULL) &&
3782 (p_next_ccw->header.flag!=CLAW_PENDING)) ||
3783 ((p_this_ccw == privptr->p_write_active_last) &&
3784 (p_this_ccw->header.flag!=CLAW_PENDING))) {
3785 /* The next CCW is OK or this is */
3786 /* the last CCW...free it @A1A */
3787 privptr->p_write_active_first=p_this_ccw->next;
3788 p_this_ccw->header.flag=CLAW_PENDING;
3789 p_this_ccw->next=privptr->p_write_free_chain;
3790 privptr->p_write_free_chain=p_this_ccw;
3791 ++privptr->write_free_count;
3792 privptr->stats.tx_bytes+= p_this_ccw->write.count;
3793 p_this_ccw=privptr->p_write_active_first;
3794 privptr->stats.tx_packets++;
3795 }
3796 else {
3797 break;
3798 }
3799 }
3800 if (privptr->write_free_count!=0) {
3801 claw_clearbit_busy(TB_NOBUFFER,dev);
3802 }
3803 /* whole chain removed? */
3804 if (privptr->p_write_active_first==NULL) {
3805 privptr->p_write_active_last=NULL;
3806 #ifdef DEBUGMSG
3807 printk(KERN_INFO "%s:%s p_write_"
3808 "active_first==NULL\n",dev->name,__FUNCTION__);
3809 #endif
3810 }
3811 #ifdef IOTRACE
3812 printk(KERN_INFO "%s: Dump arranged CCW chain \n",dev->name );
3813 p_buf=privptr->p_write_active_first;
3814 while (p_buf!=NULL) {
3815 dumpit((char *)p_buf, sizeof(struct ccwbk));
3816 p_buf=p_buf->next;
3817 }
3818 if (p_buf==NULL) {
3819 printk(KERN_INFO "%s: privptr->p_write_active_"
3820 "first==NULL\n",dev->name );
3821 }
3822 p_buf=(struct ccwbk*)privptr->p_end_ccw;
3823 dumpit((char *)p_buf, sizeof(struct endccw));
3824 #endif
3825
3826 CLAW_DBF_TEXT_(4,trace,"FWC=%d",privptr->write_free_count);
3827 #ifdef FUNCTRACE
3828 printk(KERN_INFO "%s:%s Exit on line %d free_count =%d\n",
3829 dev->name,__FUNCTION__, __LINE__,privptr->write_free_count);
3830 #endif
3831 return;
3832 }
3833
3834 /*-------------------------------------------------------------------*
3835 * claw free netdevice *
3836 * *
3837 *--------------------------------------------------------------------*/
3838 static void
3839 claw_free_netdevice(struct net_device * dev, int free_dev)
3840 {
3841 struct claw_privbk *privptr;
3842 #ifdef FUNCTRACE
3843 printk(KERN_INFO "%s:%s Enter\n",dev->name,__FUNCTION__);
3844 #endif
3845 CLAW_DBF_TEXT(2,setup,"free_dev");
3846
3847 if (!dev)
3848 return;
3849 CLAW_DBF_TEXT_(2,setup,"%s",dev->name);
3850 privptr = dev->priv;
3851 if (dev->flags & IFF_RUNNING)
3852 claw_release(dev);
3853 if (privptr) {
3854 privptr->channel[READ].ndev = NULL; /* say it's free */
3855 }
3856 dev->priv=NULL;
3857 #ifdef MODULE
3858 if (free_dev) {
3859 free_netdev(dev);
3860 }
3861 #endif
3862 CLAW_DBF_TEXT(2,setup,"feee_ok");
3863 #ifdef FUNCTRACE
3864 printk(KERN_INFO "%s:%s Exit\n",dev->name,__FUNCTION__);
3865 #endif
3866 }
3867
3868 /**
3869 * Claw init netdevice
3870 * Initialize everything of the net device except the name and the
3871 * channel structs.
3872 */
3873 static void
3874 claw_init_netdevice(struct net_device * dev)
3875 {
3876 #ifdef FUNCTRACE
3877 printk(KERN_INFO "%s:%s Enter\n",dev->name,__FUNCTION__);
3878 #endif
3879 CLAW_DBF_TEXT(2,setup,"init_dev");
3880 CLAW_DBF_TEXT_(2,setup,"%s",dev->name);
3881 if (!dev) {
3882 printk(KERN_WARNING "claw:%s BAD Device exit line %d\n",
3883 __FUNCTION__,__LINE__);
3884 CLAW_DBF_TEXT(2,setup,"baddev");
3885 return;
3886 }
3887 dev->mtu = CLAW_DEFAULT_MTU_SIZE;
3888 dev->hard_start_xmit = claw_tx;
3889 dev->open = claw_open;
3890 dev->stop = claw_release;
3891 dev->get_stats = claw_stats;
3892 dev->change_mtu = claw_change_mtu;
3893 dev->hard_header_len = 0;
3894 dev->addr_len = 0;
3895 dev->type = ARPHRD_SLIP;
3896 dev->tx_queue_len = 1300;
3897 dev->flags = IFF_POINTOPOINT | IFF_NOARP;
3898 SET_MODULE_OWNER(dev);
3899 #ifdef FUNCTRACE
3900 printk(KERN_INFO "%s:%s Exit\n",dev->name,__FUNCTION__);
3901 #endif
3902 CLAW_DBF_TEXT(2,setup,"initok");
3903 return;
3904 }
3905
3906 /**
3907 * Init a new channel in the privptr->channel[i].
3908 *
3909 * @param cdev The ccw_device to be added.
3910 *
3911 * @return 0 on success, !0 on error.
3912 */
3913 static int
3914 add_channel(struct ccw_device *cdev,int i,struct claw_privbk *privptr)
3915 {
3916 struct chbk *p_ch;
3917
3918 #ifdef FUNCTRACE
3919 printk(KERN_INFO "%s:%s Enter\n",cdev->dev.bus_id,__FUNCTION__);
3920 #endif
3921 CLAW_DBF_TEXT_(2,setup,"%s",cdev->dev.bus_id);
3922 privptr->channel[i].flag = i+1; /* Read is 1 Write is 2 */
3923 p_ch = &privptr->channel[i];
3924 p_ch->cdev = cdev;
3925 snprintf(p_ch->id, CLAW_ID_SIZE, "cl-%s", cdev->dev.bus_id);
3926 sscanf(cdev->dev.bus_id+4,"%x",&p_ch->devno);
3927 if ((p_ch->irb = kmalloc(sizeof (struct irb),GFP_KERNEL)) == NULL) {
3928 printk(KERN_WARNING "%s Out of memory in %s for irb\n",
3929 p_ch->id,__FUNCTION__);
3930 #ifdef FUNCTRACE
3931 printk(KERN_INFO "%s:%s Exit on line %d\n",
3932 p_ch->id,__FUNCTION__,__LINE__);
3933 #endif
3934 return -ENOMEM;
3935 }
3936 memset(p_ch->irb, 0, sizeof (struct irb));
3937 #ifdef FUNCTRACE
3938 printk(KERN_INFO "%s:%s Exit on line %d\n",
3939 cdev->dev.bus_id,__FUNCTION__,__LINE__);
3940 #endif
3941 return 0;
3942 }
3943
3944
3945 /**
3946 *
3947 * Setup an interface.
3948 *
3949 * @param cgdev Device to be setup.
3950 *
3951 * @returns 0 on success, !0 on failure.
3952 */
3953 static int
3954 claw_new_device(struct ccwgroup_device *cgdev)
3955 {
3956 struct claw_privbk *privptr;
3957 struct claw_env *p_env;
3958 struct net_device *dev;
3959 int ret;
3960
3961 pr_debug("%s() called\n", __FUNCTION__);
3962 printk(KERN_INFO "claw: add for %s\n",cgdev->cdev[READ]->dev.bus_id);
3963 CLAW_DBF_TEXT(2,setup,"new_dev");
3964 privptr = cgdev->dev.driver_data;
3965 cgdev->cdev[READ]->dev.driver_data = privptr;
3966 cgdev->cdev[WRITE]->dev.driver_data = privptr;
3967 if (!privptr)
3968 return -ENODEV;
3969 p_env = privptr->p_env;
3970 sscanf(cgdev->cdev[READ]->dev.bus_id+4,"%x",
3971 &p_env->devno[READ]);
3972 sscanf(cgdev->cdev[WRITE]->dev.bus_id+4,"%x",
3973 &p_env->devno[WRITE]);
3974 ret = add_channel(cgdev->cdev[0],0,privptr);
3975 if (ret == 0)
3976 ret = add_channel(cgdev->cdev[1],1,privptr);
3977 if (ret != 0) {
3978 printk(KERN_WARNING
3979 "add channel failed "
3980 "with ret = %d\n", ret);
3981 goto out;
3982 }
3983 ret = ccw_device_set_online(cgdev->cdev[READ]);
3984 if (ret != 0) {
3985 printk(KERN_WARNING
3986 "claw: ccw_device_set_online %s READ failed "
3987 "with ret = %d\n",cgdev->cdev[READ]->dev.bus_id,ret);
3988 goto out;
3989 }
3990 ret = ccw_device_set_online(cgdev->cdev[WRITE]);
3991 if (ret != 0) {
3992 printk(KERN_WARNING
3993 "claw: ccw_device_set_online %s WRITE failed "
3994 "with ret = %d\n",cgdev->cdev[WRITE]->dev.bus_id, ret);
3995 goto out;
3996 }
3997 dev = alloc_netdev(0,"claw%d",claw_init_netdevice);
3998 if (!dev) {
3999 printk(KERN_WARNING "%s:alloc_netdev failed\n",__FUNCTION__);
4000 goto out;
4001 }
4002 dev->priv = privptr;
4003 cgdev->dev.driver_data = privptr;
4004 cgdev->cdev[READ]->dev.driver_data = privptr;
4005 cgdev->cdev[WRITE]->dev.driver_data = privptr;
4006 /* sysfs magic */
4007 SET_NETDEV_DEV(dev, &cgdev->dev);
4008 if (register_netdev(dev) != 0) {
4009 claw_free_netdevice(dev, 1);
4010 CLAW_DBF_TEXT(2,trace,"regfail");
4011 goto out;
4012 }
4013 dev->flags &=~IFF_RUNNING;
4014 if (privptr->buffs_alloc == 0) {
4015 ret=init_ccw_bk(dev);
4016 if (ret !=0) {
4017 printk(KERN_WARNING
4018 "claw: init_ccw_bk failed with ret=%d\n", ret);
4019 unregister_netdev(dev);
4020 claw_free_netdevice(dev,1);
4021 CLAW_DBF_TEXT(2,trace,"ccwmem");
4022 goto out;
4023 }
4024 }
4025 privptr->channel[READ].ndev = dev;
4026 privptr->channel[WRITE].ndev = dev;
4027 privptr->p_env->ndev = dev;
4028
4029 printk(KERN_INFO "%s:readsize=%d writesize=%d "
4030 "readbuffer=%d writebuffer=%d read=0x%04x write=0x%04x\n",
4031 dev->name, p_env->read_size,
4032 p_env->write_size, p_env->read_buffers,
4033 p_env->write_buffers, p_env->devno[READ],
4034 p_env->devno[WRITE]);
4035 printk(KERN_INFO "%s:host_name:%.8s, adapter_name "
4036 ":%.8s api_type: %.8s\n",
4037 dev->name, p_env->host_name,
4038 p_env->adapter_name , p_env->api_type);
4039 return 0;
4040 out:
4041 ccw_device_set_offline(cgdev->cdev[1]);
4042 ccw_device_set_offline(cgdev->cdev[0]);
4043
4044 return -ENODEV;
4045 }
4046
4047 static void
4048 claw_purge_skb_queue(struct sk_buff_head *q)
4049 {
4050 struct sk_buff *skb;
4051
4052 CLAW_DBF_TEXT(4,trace,"purgque");
4053
4054 while ((skb = skb_dequeue(q))) {
4055 atomic_dec(&skb->users);
4056 dev_kfree_skb_any(skb);
4057 }
4058 }
4059
4060 /**
4061 * Shutdown an interface.
4062 *
4063 * @param cgdev Device to be shut down.
4064 *
4065 * @returns 0 on success, !0 on failure.
4066 */
4067 static int
4068 claw_shutdown_device(struct ccwgroup_device *cgdev)
4069 {
4070 struct claw_privbk *priv;
4071 struct net_device *ndev;
4072 int ret;
4073
4074 pr_debug("%s() called\n", __FUNCTION__);
4075 CLAW_DBF_TEXT_(2,setup,"%s",cgdev->dev.bus_id);
4076 priv = cgdev->dev.driver_data;
4077 if (!priv)
4078 return -ENODEV;
4079 ndev = priv->channel[READ].ndev;
4080 if (ndev) {
4081 /* Close the device */
4082 printk(KERN_INFO
4083 "%s: shuting down \n",ndev->name);
4084 if (ndev->flags & IFF_RUNNING)
4085 ret = claw_release(ndev);
4086 ndev->flags &=~IFF_RUNNING;
4087 unregister_netdev(ndev);
4088 ndev->priv = NULL; /* cgdev data, not ndev's to free */
4089 claw_free_netdevice(ndev, 1);
4090 priv->channel[READ].ndev = NULL;
4091 priv->channel[WRITE].ndev = NULL;
4092 priv->p_env->ndev = NULL;
4093 }
4094 ccw_device_set_offline(cgdev->cdev[1]);
4095 ccw_device_set_offline(cgdev->cdev[0]);
4096 return 0;
4097 }
4098
4099 static void
4100 claw_remove_device(struct ccwgroup_device *cgdev)
4101 {
4102 struct claw_privbk *priv;
4103
4104 pr_debug("%s() called\n", __FUNCTION__);
4105 CLAW_DBF_TEXT_(2,setup,"%s",cgdev->dev.bus_id);
4106 priv = cgdev->dev.driver_data;
4107 if (!priv) {
4108 printk(KERN_WARNING "claw: %s() no Priv exiting\n",__FUNCTION__);
4109 return;
4110 }
4111 printk(KERN_INFO "claw: %s() called %s will be removed.\n",
4112 __FUNCTION__,cgdev->cdev[0]->dev.bus_id);
4113 if (cgdev->state == CCWGROUP_ONLINE)
4114 claw_shutdown_device(cgdev);
4115 claw_remove_files(&cgdev->dev);
4116 kfree(priv->p_mtc_envelope);
4117 priv->p_mtc_envelope=NULL;
4118 kfree(priv->p_env);
4119 priv->p_env=NULL;
4120 kfree(priv->channel[0].irb);
4121 priv->channel[0].irb=NULL;
4122 kfree(priv->channel[1].irb);
4123 priv->channel[1].irb=NULL;
4124 kfree(priv);
4125 cgdev->dev.driver_data=NULL;
4126 cgdev->cdev[READ]->dev.driver_data = NULL;
4127 cgdev->cdev[WRITE]->dev.driver_data = NULL;
4128 put_device(&cgdev->dev);
4129 }
4130
4131
4132 /*
4133 * sysfs attributes
4134 */
4135 static ssize_t
4136 claw_hname_show(struct device *dev, struct device_attribute *attr, char *buf)
4137 {
4138 struct claw_privbk *priv;
4139 struct claw_env * p_env;
4140
4141 priv = dev->driver_data;
4142 if (!priv)
4143 return -ENODEV;
4144 p_env = priv->p_env;
4145 return sprintf(buf, "%s\n",p_env->host_name);
4146 }
4147
4148 static ssize_t
4149 claw_hname_write(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
4150 {
4151 struct claw_privbk *priv;
4152 struct claw_env * p_env;
4153
4154 priv = dev->driver_data;
4155 if (!priv)
4156 return -ENODEV;
4157 p_env = priv->p_env;
4158 if (count > MAX_NAME_LEN+1)
4159 return -EINVAL;
4160 memset(p_env->host_name, 0x20, MAX_NAME_LEN);
4161 strncpy(p_env->host_name,buf, count);
4162 p_env->host_name[count-1] = 0x20; /* clear extra 0x0a */
4163 p_env->host_name[MAX_NAME_LEN] = 0x00;
4164 CLAW_DBF_TEXT(2,setup,"HstnSet");
4165 CLAW_DBF_TEXT_(2,setup,"%s",p_env->host_name);
4166
4167 return count;
4168 }
4169
4170 static DEVICE_ATTR(host_name, 0644, claw_hname_show, claw_hname_write);
4171
4172 static ssize_t
4173 claw_adname_show(struct device *dev, struct device_attribute *attr, char *buf)
4174 {
4175 struct claw_privbk *priv;
4176 struct claw_env * p_env;
4177
4178 priv = dev->driver_data;
4179 if (!priv)
4180 return -ENODEV;
4181 p_env = priv->p_env;
4182 return sprintf(buf, "%s\n",p_env->adapter_name);
4183 }
4184
4185 static ssize_t
4186 claw_adname_write(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
4187 {
4188 struct claw_privbk *priv;
4189 struct claw_env * p_env;
4190
4191 priv = dev->driver_data;
4192 if (!priv)
4193 return -ENODEV;
4194 p_env = priv->p_env;
4195 if (count > MAX_NAME_LEN+1)
4196 return -EINVAL;
4197 memset(p_env->adapter_name, 0x20, MAX_NAME_LEN);
4198 strncpy(p_env->adapter_name,buf, count);
4199 p_env->adapter_name[count-1] = 0x20; /* clear extra 0x0a */
4200 p_env->adapter_name[MAX_NAME_LEN] = 0x00;
4201 CLAW_DBF_TEXT(2,setup,"AdnSet");
4202 CLAW_DBF_TEXT_(2,setup,"%s",p_env->adapter_name);
4203
4204 return count;
4205 }
4206
4207 static DEVICE_ATTR(adapter_name, 0644, claw_adname_show, claw_adname_write);
4208
4209 static ssize_t
4210 claw_apname_show(struct device *dev, struct device_attribute *attr, char *buf)
4211 {
4212 struct claw_privbk *priv;
4213 struct claw_env * p_env;
4214
4215 priv = dev->driver_data;
4216 if (!priv)
4217 return -ENODEV;
4218 p_env = priv->p_env;
4219 return sprintf(buf, "%s\n",
4220 p_env->api_type);
4221 }
4222
4223 static ssize_t
4224 claw_apname_write(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
4225 {
4226 struct claw_privbk *priv;
4227 struct claw_env * p_env;
4228
4229 priv = dev->driver_data;
4230 if (!priv)
4231 return -ENODEV;
4232 p_env = priv->p_env;
4233 if (count > MAX_NAME_LEN+1)
4234 return -EINVAL;
4235 memset(p_env->api_type, 0x20, MAX_NAME_LEN);
4236 strncpy(p_env->api_type,buf, count);
4237 p_env->api_type[count-1] = 0x20; /* we get a loose 0x0a */
4238 p_env->api_type[MAX_NAME_LEN] = 0x00;
4239 if(strncmp(p_env->api_type,WS_APPL_NAME_PACKED,6) == 0) {
4240 p_env->read_size=DEF_PACK_BUFSIZE;
4241 p_env->write_size=DEF_PACK_BUFSIZE;
4242 p_env->packing=PACKING_ASK;
4243 CLAW_DBF_TEXT(2,setup,"PACKING");
4244 }
4245 else {
4246 p_env->packing=0;
4247 p_env->read_size=CLAW_FRAME_SIZE;
4248 p_env->write_size=CLAW_FRAME_SIZE;
4249 CLAW_DBF_TEXT(2,setup,"ApiSet");
4250 }
4251 CLAW_DBF_TEXT_(2,setup,"%s",p_env->api_type);
4252 return count;
4253 }
4254
4255 static DEVICE_ATTR(api_type, 0644, claw_apname_show, claw_apname_write);
4256
4257 static ssize_t
4258 claw_wbuff_show(struct device *dev, struct device_attribute *attr, char *buf)
4259 {
4260 struct claw_privbk *priv;
4261 struct claw_env * p_env;
4262
4263 priv = dev->driver_data;
4264 if (!priv)
4265 return -ENODEV;
4266 p_env = priv->p_env;
4267 return sprintf(buf, "%d\n", p_env->write_buffers);
4268 }
4269
4270 static ssize_t
4271 claw_wbuff_write(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
4272 {
4273 struct claw_privbk *priv;
4274 struct claw_env * p_env;
4275 int nnn,max;
4276
4277 priv = dev->driver_data;
4278 if (!priv)
4279 return -ENODEV;
4280 p_env = priv->p_env;
4281 sscanf(buf, "%i", &nnn);
4282 if (p_env->packing) {
4283 max = 64;
4284 }
4285 else {
4286 max = 512;
4287 }
4288 if ((nnn > max ) || (nnn < 2))
4289 return -EINVAL;
4290 p_env->write_buffers = nnn;
4291 CLAW_DBF_TEXT(2,setup,"Wbufset");
4292 CLAW_DBF_TEXT_(2,setup,"WB=%d",p_env->write_buffers);
4293 return count;
4294 }
4295
4296 static DEVICE_ATTR(write_buffer, 0644, claw_wbuff_show, claw_wbuff_write);
4297
4298 static ssize_t
4299 claw_rbuff_show(struct device *dev, struct device_attribute *attr, char *buf)
4300 {
4301 struct claw_privbk *priv;
4302 struct claw_env * p_env;
4303
4304 priv = dev->driver_data;
4305 if (!priv)
4306 return -ENODEV;
4307 p_env = priv->p_env;
4308 return sprintf(buf, "%d\n", p_env->read_buffers);
4309 }
4310
4311 static ssize_t
4312 claw_rbuff_write(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
4313 {
4314 struct claw_privbk *priv;
4315 struct claw_env *p_env;
4316 int nnn,max;
4317
4318 priv = dev->driver_data;
4319 if (!priv)
4320 return -ENODEV;
4321 p_env = priv->p_env;
4322 sscanf(buf, "%i", &nnn);
4323 if (p_env->packing) {
4324 max = 64;
4325 }
4326 else {
4327 max = 512;
4328 }
4329 if ((nnn > max ) || (nnn < 2))
4330 return -EINVAL;
4331 p_env->read_buffers = nnn;
4332 CLAW_DBF_TEXT(2,setup,"Rbufset");
4333 CLAW_DBF_TEXT_(2,setup,"RB=%d",p_env->read_buffers);
4334 return count;
4335 }
4336
4337 static DEVICE_ATTR(read_buffer, 0644, claw_rbuff_show, claw_rbuff_write);
4338
4339 static struct attribute *claw_attr[] = {
4340 &dev_attr_read_buffer.attr,
4341 &dev_attr_write_buffer.attr,
4342 &dev_attr_adapter_name.attr,
4343 &dev_attr_api_type.attr,
4344 &dev_attr_host_name.attr,
4345 NULL,
4346 };
4347
4348 static struct attribute_group claw_attr_group = {
4349 .attrs = claw_attr,
4350 };
4351
4352 static int
4353 claw_add_files(struct device *dev)
4354 {
4355 pr_debug("%s() called\n", __FUNCTION__);
4356 CLAW_DBF_TEXT(2,setup,"add_file");
4357 return sysfs_create_group(&dev->kobj, &claw_attr_group);
4358 }
4359
4360 static void
4361 claw_remove_files(struct device *dev)
4362 {
4363 pr_debug("%s() called\n", __FUNCTION__);
4364 CLAW_DBF_TEXT(2,setup,"rem_file");
4365 sysfs_remove_group(&dev->kobj, &claw_attr_group);
4366 }
4367
4368 /*--------------------------------------------------------------------*
4369 * claw_init and cleanup *
4370 *---------------------------------------------------------------------*/
4371
4372 static void __exit
4373 claw_cleanup(void)
4374 {
4375 unregister_cu3088_discipline(&claw_group_driver);
4376 claw_unregister_debug_facility();
4377 printk(KERN_INFO "claw: Driver unloaded\n");
4378
4379 }
4380
4381 /**
4382 * Initialize module.
4383 * This is called just after the module is loaded.
4384 *
4385 * @return 0 on success, !0 on error.
4386 */
4387 static int __init
4388 claw_init(void)
4389 {
4390 int ret = 0;
4391 printk(KERN_INFO "claw: starting driver\n");
4392
4393 #ifdef FUNCTRACE
4394 printk(KERN_INFO "claw: %s() enter \n",__FUNCTION__);
4395 #endif
4396 ret = claw_register_debug_facility();
4397 if (ret) {
4398 printk(KERN_WARNING "claw: %s() debug_register failed %d\n",
4399 __FUNCTION__,ret);
4400 return ret;
4401 }
4402 CLAW_DBF_TEXT(2,setup,"init_mod");
4403 ret = register_cu3088_discipline(&claw_group_driver);
4404 if (ret) {
4405 claw_unregister_debug_facility();
4406 printk(KERN_WARNING "claw; %s() cu3088 register failed %d\n",
4407 __FUNCTION__,ret);
4408 }
4409 #ifdef FUNCTRACE
4410 printk(KERN_INFO "claw: %s() exit \n",__FUNCTION__);
4411 #endif
4412 return ret;
4413 }
4414
4415 module_init(claw_init);
4416 module_exit(claw_cleanup);
4417
4418
4419
4420 /*--------------------------------------------------------------------*
4421 * End of File *
4422 *---------------------------------------------------------------------*/
4423
4424
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree