1
2
3
4
5
6
7
8
9
10
11
12
13#define KMSG_COMPONENT "lcs"
14#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
15
16#include <linux/module.h>
17#include <linux/if.h>
18#include <linux/netdevice.h>
19#include <linux/etherdevice.h>
20#include <linux/fddidevice.h>
21#include <linux/inetdevice.h>
22#include <linux/in.h>
23#include <linux/igmp.h>
24#include <linux/delay.h>
25#include <linux/kthread.h>
26#include <linux/slab.h>
27#include <net/arp.h>
28#include <net/ip.h>
29
30#include <asm/debug.h>
31#include <asm/idals.h>
32#include <asm/timex.h>
33#include <linux/device.h>
34#include <asm/ccwgroup.h>
35
36#include "lcs.h"
37
38
39#if !defined(CONFIG_ETHERNET) && !defined(CONFIG_FDDI)
40#error Cannot compile lcs.c without some net devices switched on.
41#endif
42
43
44
45
46
47static char version[] __initdata = "LCS driver";
48
49
50
51
52static struct device *lcs_root_dev;
53
54
55
56
57static void lcs_tasklet(unsigned long);
58static void lcs_start_kernel_thread(struct work_struct *);
59static void lcs_get_frames_cb(struct lcs_channel *, struct lcs_buffer *);
60#ifdef CONFIG_IP_MULTICAST
61static int lcs_send_delipm(struct lcs_card *, struct lcs_ipm_list *);
62#endif
63static int lcs_recovery(void *ptr);
64
65
66
67
68static char debug_buffer[255];
69static debug_info_t *lcs_dbf_setup;
70static debug_info_t *lcs_dbf_trace;
71
72
73
74
75static void
76lcs_unregister_debug_facility(void)
77{
78 debug_unregister(lcs_dbf_setup);
79 debug_unregister(lcs_dbf_trace);
80}
81
82static int
83lcs_register_debug_facility(void)
84{
85 lcs_dbf_setup = debug_register("lcs_setup", 2, 1, 8);
86 lcs_dbf_trace = debug_register("lcs_trace", 4, 1, 8);
87 if (lcs_dbf_setup == NULL || lcs_dbf_trace == NULL) {
88 pr_err("Not enough memory for debug facility.\n");
89 lcs_unregister_debug_facility();
90 return -ENOMEM;
91 }
92 debug_register_view(lcs_dbf_setup, &debug_hex_ascii_view);
93 debug_set_level(lcs_dbf_setup, 2);
94 debug_register_view(lcs_dbf_trace, &debug_hex_ascii_view);
95 debug_set_level(lcs_dbf_trace, 2);
96 return 0;
97}
98
99
100
101
102static int
103lcs_alloc_channel(struct lcs_channel *channel)
104{
105 int cnt;
106
107 LCS_DBF_TEXT(2, setup, "ichalloc");
108 for (cnt = 0; cnt < LCS_NUM_BUFFS; cnt++) {
109
110 channel->iob[cnt].data =
111 kzalloc(LCS_IOBUFFERSIZE, GFP_DMA | GFP_KERNEL);
112 if (channel->iob[cnt].data == NULL)
113 break;
114 channel->iob[cnt].state = LCS_BUF_STATE_EMPTY;
115 }
116 if (cnt < LCS_NUM_BUFFS) {
117
118 LCS_DBF_TEXT(2, setup, "echalloc");
119 while (cnt-- > 0)
120 kfree(channel->iob[cnt].data);
121 return -ENOMEM;
122 }
123 return 0;
124}
125
126
127
128
129static void
130lcs_free_channel(struct lcs_channel *channel)
131{
132 int cnt;
133
134 LCS_DBF_TEXT(2, setup, "ichfree");
135 for (cnt = 0; cnt < LCS_NUM_BUFFS; cnt++) {
136 kfree(channel->iob[cnt].data);
137 channel->iob[cnt].data = NULL;
138 }
139}
140
141
142
143
144static void
145lcs_cleanup_channel(struct lcs_channel *channel)
146{
147 LCS_DBF_TEXT(3, setup, "cleanch");
148
149 tasklet_kill(&channel->irq_tasklet);
150
151 lcs_free_channel(channel);
152}
153
154
155
156
157static void
158lcs_free_card(struct lcs_card *card)
159{
160 LCS_DBF_TEXT(2, setup, "remcard");
161 LCS_DBF_HEX(2, setup, &card, sizeof(void*));
162 kfree(card);
163}
164
165
166
167
168static struct lcs_card *
169lcs_alloc_card(void)
170{
171 struct lcs_card *card;
172 int rc;
173
174 LCS_DBF_TEXT(2, setup, "alloclcs");
175
176 card = kzalloc(sizeof(struct lcs_card), GFP_KERNEL | GFP_DMA);
177 if (card == NULL)
178 return NULL;
179 card->lan_type = LCS_FRAME_TYPE_AUTO;
180 card->pkt_seq = 0;
181 card->lancmd_timeout = LCS_LANCMD_TIMEOUT_DEFAULT;
182
183 rc = lcs_alloc_channel(&card->read);
184 if (rc){
185 LCS_DBF_TEXT(2, setup, "iccwerr");
186 lcs_free_card(card);
187 return NULL;
188 }
189
190 rc = lcs_alloc_channel(&card->write);
191 if (rc) {
192 LCS_DBF_TEXT(2, setup, "iccwerr");
193 lcs_cleanup_channel(&card->read);
194 lcs_free_card(card);
195 return NULL;
196 }
197
198#ifdef CONFIG_IP_MULTICAST
199 INIT_LIST_HEAD(&card->ipm_list);
200#endif
201 LCS_DBF_HEX(2, setup, &card, sizeof(void*));
202 return card;
203}
204
205
206
207
208static void
209lcs_setup_read_ccws(struct lcs_card *card)
210{
211 int cnt;
212
213 LCS_DBF_TEXT(2, setup, "ireadccw");
214
215 memset(card->read.ccws, 0, sizeof (struct ccw1) * (LCS_NUM_BUFFS + 1));
216 for (cnt = 0; cnt < LCS_NUM_BUFFS; cnt++) {
217 card->read.ccws[cnt].cmd_code = LCS_CCW_READ;
218 card->read.ccws[cnt].count = LCS_IOBUFFERSIZE;
219 card->read.ccws[cnt].flags =
220 CCW_FLAG_CC | CCW_FLAG_SLI | CCW_FLAG_PCI;
221
222
223
224
225 card->read.ccws[cnt].cda =
226 (__u32) __pa(card->read.iob[cnt].data);
227 ((struct lcs_header *)
228 card->read.iob[cnt].data)->offset = LCS_ILLEGAL_OFFSET;
229 card->read.iob[cnt].callback = lcs_get_frames_cb;
230 card->read.iob[cnt].state = LCS_BUF_STATE_READY;
231 card->read.iob[cnt].count = LCS_IOBUFFERSIZE;
232 }
233 card->read.ccws[0].flags &= ~CCW_FLAG_PCI;
234 card->read.ccws[LCS_NUM_BUFFS - 1].flags &= ~CCW_FLAG_PCI;
235 card->read.ccws[LCS_NUM_BUFFS - 1].flags |= CCW_FLAG_SUSPEND;
236
237 card->read.ccws[LCS_NUM_BUFFS].cmd_code = LCS_CCW_TRANSFER;
238 card->read.ccws[LCS_NUM_BUFFS].cda =
239 (__u32) __pa(card->read.ccws);
240
241 card->read.state = LCS_CH_STATE_INIT;
242
243 card->read.io_idx = 0;
244 card->read.buf_idx = 0;
245}
246
247static void
248lcs_setup_read(struct lcs_card *card)
249{
250 LCS_DBF_TEXT(3, setup, "initread");
251
252 lcs_setup_read_ccws(card);
253
254 card->read.irq_tasklet.data = (unsigned long) &card->read;
255 card->read.irq_tasklet.func = lcs_tasklet;
256
257 init_waitqueue_head(&card->read.wait_q);
258}
259
260
261
262
263static void
264lcs_setup_write_ccws(struct lcs_card *card)
265{
266 int cnt;
267
268 LCS_DBF_TEXT(3, setup, "iwritccw");
269
270 memset(card->write.ccws, 0, sizeof(struct ccw1) * (LCS_NUM_BUFFS + 1));
271 for (cnt = 0; cnt < LCS_NUM_BUFFS; cnt++) {
272 card->write.ccws[cnt].cmd_code = LCS_CCW_WRITE;
273 card->write.ccws[cnt].count = 0;
274 card->write.ccws[cnt].flags =
275 CCW_FLAG_SUSPEND | CCW_FLAG_CC | CCW_FLAG_SLI;
276
277
278
279
280 card->write.ccws[cnt].cda =
281 (__u32) __pa(card->write.iob[cnt].data);
282 }
283
284 card->write.ccws[LCS_NUM_BUFFS].cmd_code = LCS_CCW_TRANSFER;
285 card->write.ccws[LCS_NUM_BUFFS].cda =
286 (__u32) __pa(card->write.ccws);
287
288 card->read.state = LCS_CH_STATE_INIT;
289
290 card->write.io_idx = 0;
291 card->write.buf_idx = 0;
292}
293
294static void
295lcs_setup_write(struct lcs_card *card)
296{
297 LCS_DBF_TEXT(3, setup, "initwrit");
298
299 lcs_setup_write_ccws(card);
300
301 card->write.irq_tasklet.data = (unsigned long) &card->write;
302 card->write.irq_tasklet.func = lcs_tasklet;
303
304 init_waitqueue_head(&card->write.wait_q);
305}
306
307static void
308lcs_set_allowed_threads(struct lcs_card *card, unsigned long threads)
309{
310 unsigned long flags;
311
312 spin_lock_irqsave(&card->mask_lock, flags);
313 card->thread_allowed_mask = threads;
314 spin_unlock_irqrestore(&card->mask_lock, flags);
315 wake_up(&card->wait_q);
316}
317static int lcs_threads_running(struct lcs_card *card, unsigned long threads)
318{
319 unsigned long flags;
320 int rc = 0;
321
322 spin_lock_irqsave(&card->mask_lock, flags);
323 rc = (card->thread_running_mask & threads);
324 spin_unlock_irqrestore(&card->mask_lock, flags);
325 return rc;
326}
327
328static int
329lcs_wait_for_threads(struct lcs_card *card, unsigned long threads)
330{
331 return wait_event_interruptible(card->wait_q,
332 lcs_threads_running(card, threads) == 0);
333}
334
335static int lcs_set_thread_start_bit(struct lcs_card *card, unsigned long thread)
336{
337 unsigned long flags;
338
339 spin_lock_irqsave(&card->mask_lock, flags);
340 if ( !(card->thread_allowed_mask & thread) ||
341 (card->thread_start_mask & thread) ) {
342 spin_unlock_irqrestore(&card->mask_lock, flags);
343 return -EPERM;
344 }
345 card->thread_start_mask |= thread;
346 spin_unlock_irqrestore(&card->mask_lock, flags);
347 return 0;
348}
349
350static void
351lcs_clear_thread_running_bit(struct lcs_card *card, unsigned long thread)
352{
353 unsigned long flags;
354
355 spin_lock_irqsave(&card->mask_lock, flags);
356 card->thread_running_mask &= ~thread;
357 spin_unlock_irqrestore(&card->mask_lock, flags);
358 wake_up(&card->wait_q);
359}
360
361static int __lcs_do_run_thread(struct lcs_card *card, unsigned long thread)
362{
363 unsigned long flags;
364 int rc = 0;
365
366 spin_lock_irqsave(&card->mask_lock, flags);
367 if (card->thread_start_mask & thread){
368 if ((card->thread_allowed_mask & thread) &&
369 !(card->thread_running_mask & thread)){
370 rc = 1;
371 card->thread_start_mask &= ~thread;
372 card->thread_running_mask |= thread;
373 } else
374 rc = -EPERM;
375 }
376 spin_unlock_irqrestore(&card->mask_lock, flags);
377 return rc;
378}
379
380static int
381lcs_do_run_thread(struct lcs_card *card, unsigned long thread)
382{
383 int rc = 0;
384 wait_event(card->wait_q,
385 (rc = __lcs_do_run_thread(card, thread)) >= 0);
386 return rc;
387}
388
389static int
390lcs_do_start_thread(struct lcs_card *card, unsigned long thread)
391{
392 unsigned long flags;
393 int rc = 0;
394
395 spin_lock_irqsave(&card->mask_lock, flags);
396 LCS_DBF_TEXT_(4, trace, " %02x%02x%02x",
397 (u8) card->thread_start_mask,
398 (u8) card->thread_allowed_mask,
399 (u8) card->thread_running_mask);
400 rc = (card->thread_start_mask & thread);
401 spin_unlock_irqrestore(&card->mask_lock, flags);
402 return rc;
403}
404
405
406
407
408static void
409lcs_setup_card(struct lcs_card *card)
410{
411 LCS_DBF_TEXT(2, setup, "initcard");
412 LCS_DBF_HEX(2, setup, &card, sizeof(void*));
413
414 lcs_setup_read(card);
415 lcs_setup_write(card);
416
417 card->state = DEV_STATE_DOWN;
418 card->tx_buffer = NULL;
419 card->tx_emitted = 0;
420
421 init_waitqueue_head(&card->wait_q);
422 spin_lock_init(&card->lock);
423 spin_lock_init(&card->ipm_lock);
424 spin_lock_init(&card->mask_lock);
425#ifdef CONFIG_IP_MULTICAST
426 INIT_LIST_HEAD(&card->ipm_list);
427#endif
428 INIT_LIST_HEAD(&card->lancmd_waiters);
429}
430
431static void lcs_clear_multicast_list(struct lcs_card *card)
432{
433#ifdef CONFIG_IP_MULTICAST
434 struct lcs_ipm_list *ipm;
435 unsigned long flags;
436
437
438 LCS_DBF_TEXT(3, setup, "clmclist");
439 spin_lock_irqsave(&card->ipm_lock, flags);
440 while (!list_empty(&card->ipm_list)){
441 ipm = list_entry(card->ipm_list.next,
442 struct lcs_ipm_list, list);
443 list_del(&ipm->list);
444 if (ipm->ipm_state != LCS_IPM_STATE_SET_REQUIRED){
445 spin_unlock_irqrestore(&card->ipm_lock, flags);
446 lcs_send_delipm(card, ipm);
447 spin_lock_irqsave(&card->ipm_lock, flags);
448 }
449 kfree(ipm);
450 }
451 spin_unlock_irqrestore(&card->ipm_lock, flags);
452#endif
453}
454
455
456
457
458static void
459lcs_cleanup_card(struct lcs_card *card)
460{
461
462 LCS_DBF_TEXT(3, setup, "cleancrd");
463 LCS_DBF_HEX(2,setup,&card,sizeof(void*));
464
465 if (card->dev != NULL)
466 free_netdev(card->dev);
467
468 lcs_cleanup_channel(&card->write);
469 lcs_cleanup_channel(&card->read);
470}
471
472
473
474
475static int
476lcs_start_channel(struct lcs_channel *channel)
477{
478 unsigned long flags;
479 int rc;
480
481 LCS_DBF_TEXT_(4, trace,"ssch%s", dev_name(&channel->ccwdev->dev));
482 spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
483 rc = ccw_device_start(channel->ccwdev,
484 channel->ccws + channel->io_idx, 0, 0,
485 DOIO_DENY_PREFETCH | DOIO_ALLOW_SUSPEND);
486 if (rc == 0)
487 channel->state = LCS_CH_STATE_RUNNING;
488 spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
489 if (rc) {
490 LCS_DBF_TEXT_(4,trace,"essh%s",
491 dev_name(&channel->ccwdev->dev));
492 dev_err(&channel->ccwdev->dev,
493 "Starting an LCS device resulted in an error,"
494 " rc=%d!\n", rc);
495 }
496 return rc;
497}
498
499static int
500lcs_clear_channel(struct lcs_channel *channel)
501{
502 unsigned long flags;
503 int rc;
504
505 LCS_DBF_TEXT(4,trace,"clearch");
506 LCS_DBF_TEXT_(4, trace, "%s", dev_name(&channel->ccwdev->dev));
507 spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
508 rc = ccw_device_clear(channel->ccwdev, 0);
509 spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
510 if (rc) {
511 LCS_DBF_TEXT_(4, trace, "ecsc%s",
512 dev_name(&channel->ccwdev->dev));
513 return rc;
514 }
515 wait_event(channel->wait_q, (channel->state == LCS_CH_STATE_CLEARED));
516 channel->state = LCS_CH_STATE_STOPPED;
517 return rc;
518}
519
520
521
522
523
524static int
525lcs_stop_channel(struct lcs_channel *channel)
526{
527 unsigned long flags;
528 int rc;
529
530 if (channel->state == LCS_CH_STATE_STOPPED)
531 return 0;
532 LCS_DBF_TEXT(4,trace,"haltsch");
533 LCS_DBF_TEXT_(4, trace, "%s", dev_name(&channel->ccwdev->dev));
534 channel->state = LCS_CH_STATE_INIT;
535 spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
536 rc = ccw_device_halt(channel->ccwdev, 0);
537 spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
538 if (rc) {
539 LCS_DBF_TEXT_(4, trace, "ehsc%s",
540 dev_name(&channel->ccwdev->dev));
541 return rc;
542 }
543
544 wait_event(channel->wait_q, (channel->state == LCS_CH_STATE_HALTED));
545 lcs_clear_channel(channel);
546 return 0;
547}
548
549
550
551
552static int
553lcs_start_channels(struct lcs_card *card)
554{
555 int rc;
556
557 LCS_DBF_TEXT(2, trace, "chstart");
558
559 rc = lcs_start_channel(&card->read);
560 if (rc)
561 return rc;
562
563 rc = lcs_start_channel(&card->write);
564 if (rc)
565 lcs_stop_channel(&card->read);
566 return rc;
567}
568
569
570
571
572static int
573lcs_stop_channels(struct lcs_card *card)
574{
575 LCS_DBF_TEXT(2, trace, "chhalt");
576 lcs_stop_channel(&card->read);
577 lcs_stop_channel(&card->write);
578 return 0;
579}
580
581
582
583
584static struct lcs_buffer *
585__lcs_get_buffer(struct lcs_channel *channel)
586{
587 int index;
588
589 LCS_DBF_TEXT(5, trace, "_getbuff");
590 index = channel->io_idx;
591 do {
592 if (channel->iob[index].state == LCS_BUF_STATE_EMPTY) {
593 channel->iob[index].state = LCS_BUF_STATE_LOCKED;
594 return channel->iob + index;
595 }
596 index = (index + 1) & (LCS_NUM_BUFFS - 1);
597 } while (index != channel->io_idx);
598 return NULL;
599}
600
601static struct lcs_buffer *
602lcs_get_buffer(struct lcs_channel *channel)
603{
604 struct lcs_buffer *buffer;
605 unsigned long flags;
606
607 LCS_DBF_TEXT(5, trace, "getbuff");
608 spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
609 buffer = __lcs_get_buffer(channel);
610 spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
611 return buffer;
612}
613
614
615
616
617static int
618__lcs_resume_channel(struct lcs_channel *channel)
619{
620 int rc;
621
622 if (channel->state != LCS_CH_STATE_SUSPENDED)
623 return 0;
624 if (channel->ccws[channel->io_idx].flags & CCW_FLAG_SUSPEND)
625 return 0;
626 LCS_DBF_TEXT_(5, trace, "rsch%s", dev_name(&channel->ccwdev->dev));
627 rc = ccw_device_resume(channel->ccwdev);
628 if (rc) {
629 LCS_DBF_TEXT_(4, trace, "ersc%s",
630 dev_name(&channel->ccwdev->dev));
631 dev_err(&channel->ccwdev->dev,
632 "Sending data from the LCS device to the LAN failed"
633 " with rc=%d\n",rc);
634 } else
635 channel->state = LCS_CH_STATE_RUNNING;
636 return rc;
637
638}
639
640
641
642
643static void __lcs_ready_buffer_bits(struct lcs_channel *channel, int index)
644{
645 int prev, next;
646
647 LCS_DBF_TEXT(5, trace, "rdybits");
648 prev = (index - 1) & (LCS_NUM_BUFFS - 1);
649 next = (index + 1) & (LCS_NUM_BUFFS - 1);
650
651 if (channel->ccws[next].flags & CCW_FLAG_SUSPEND) {
652
653 if (!(channel->ccws[prev].flags & CCW_FLAG_SUSPEND))
654
655 channel->ccws[index].flags |= CCW_FLAG_PCI;
656
657 channel->ccws[index].flags &= ~CCW_FLAG_SUSPEND;
658 }
659}
660
661static int
662lcs_ready_buffer(struct lcs_channel *channel, struct lcs_buffer *buffer)
663{
664 unsigned long flags;
665 int index, rc;
666
667 LCS_DBF_TEXT(5, trace, "rdybuff");
668 BUG_ON(buffer->state != LCS_BUF_STATE_LOCKED &&
669 buffer->state != LCS_BUF_STATE_PROCESSED);
670 spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
671 buffer->state = LCS_BUF_STATE_READY;
672 index = buffer - channel->iob;
673
674 channel->ccws[index].count = buffer->count;
675
676 __lcs_ready_buffer_bits(channel, index);
677 rc = __lcs_resume_channel(channel);
678 spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
679 return rc;
680}
681
682
683
684
685
686
687static int
688__lcs_processed_buffer(struct lcs_channel *channel, struct lcs_buffer *buffer)
689{
690 int index, prev, next;
691
692 LCS_DBF_TEXT(5, trace, "prcsbuff");
693 BUG_ON(buffer->state != LCS_BUF_STATE_READY);
694 buffer->state = LCS_BUF_STATE_PROCESSED;
695 index = buffer - channel->iob;
696 prev = (index - 1) & (LCS_NUM_BUFFS - 1);
697 next = (index + 1) & (LCS_NUM_BUFFS - 1);
698
699 channel->ccws[index].flags |= CCW_FLAG_SUSPEND;
700 channel->ccws[index].flags &= ~CCW_FLAG_PCI;
701
702 if (channel->iob[prev].state == LCS_BUF_STATE_READY) {
703
704
705
706
707
708
709 __lcs_ready_buffer_bits(channel, prev);
710 }
711
712 channel->ccws[next].flags &= ~CCW_FLAG_PCI;
713 return __lcs_resume_channel(channel);
714}
715
716
717
718
719static void
720lcs_release_buffer(struct lcs_channel *channel, struct lcs_buffer *buffer)
721{
722 unsigned long flags;
723
724 LCS_DBF_TEXT(5, trace, "relbuff");
725 BUG_ON(buffer->state != LCS_BUF_STATE_LOCKED &&
726 buffer->state != LCS_BUF_STATE_PROCESSED);
727 spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
728 buffer->state = LCS_BUF_STATE_EMPTY;
729 spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
730}
731
732
733
734
735static struct lcs_buffer *
736lcs_get_lancmd(struct lcs_card *card, int count)
737{
738 struct lcs_buffer *buffer;
739 struct lcs_cmd *cmd;
740
741 LCS_DBF_TEXT(4, trace, "getlncmd");
742
743 wait_event(card->write.wait_q,
744 ((buffer = lcs_get_buffer(&card->write)) != NULL));
745 count += sizeof(struct lcs_header);
746 *(__u16 *)(buffer->data + count) = 0;
747 buffer->count = count + sizeof(__u16);
748 buffer->callback = lcs_release_buffer;
749 cmd = (struct lcs_cmd *) buffer->data;
750 cmd->offset = count;
751 cmd->type = LCS_FRAME_TYPE_CONTROL;
752 cmd->slot = 0;
753 return buffer;
754}
755
756
757static void
758lcs_get_reply(struct lcs_reply *reply)
759{
760 refcount_inc(&reply->refcnt);
761}
762
763static void
764lcs_put_reply(struct lcs_reply *reply)
765{
766 if (refcount_dec_and_test(&reply->refcnt))
767 kfree(reply);
768}
769
770static struct lcs_reply *
771lcs_alloc_reply(struct lcs_cmd *cmd)
772{
773 struct lcs_reply *reply;
774
775 LCS_DBF_TEXT(4, trace, "getreply");
776
777 reply = kzalloc(sizeof(struct lcs_reply), GFP_ATOMIC);
778 if (!reply)
779 return NULL;
780 refcount_set(&reply->refcnt, 1);
781 reply->sequence_no = cmd->sequence_no;
782 reply->received = 0;
783 reply->rc = 0;
784 init_waitqueue_head(&reply->wait_q);
785
786 return reply;
787}
788
789
790
791
792static void
793lcs_notify_lancmd_waiters(struct lcs_card *card, struct lcs_cmd *cmd)
794{
795 struct list_head *l, *n;
796 struct lcs_reply *reply;
797
798 LCS_DBF_TEXT(4, trace, "notiwait");
799 spin_lock(&card->lock);
800 list_for_each_safe(l, n, &card->lancmd_waiters) {
801 reply = list_entry(l, struct lcs_reply, list);
802 if (reply->sequence_no == cmd->sequence_no) {
803 lcs_get_reply(reply);
804 list_del_init(&reply->list);
805 if (reply->callback != NULL)
806 reply->callback(card, cmd);
807 reply->received = 1;
808 reply->rc = cmd->return_code;
809 wake_up(&reply->wait_q);
810 lcs_put_reply(reply);
811 break;
812 }
813 }
814 spin_unlock(&card->lock);
815}
816
817
818
819
820static void
821lcs_lancmd_timeout(struct timer_list *t)
822{
823 struct lcs_reply *reply = from_timer(reply, t, timer);
824 struct lcs_reply *list_reply, *r;
825 unsigned long flags;
826
827 LCS_DBF_TEXT(4, trace, "timeout");
828 spin_lock_irqsave(&reply->card->lock, flags);
829 list_for_each_entry_safe(list_reply, r,
830 &reply->card->lancmd_waiters,list) {
831 if (reply == list_reply) {
832 lcs_get_reply(reply);
833 list_del_init(&reply->list);
834 spin_unlock_irqrestore(&reply->card->lock, flags);
835 reply->received = 1;
836 reply->rc = -ETIME;
837 wake_up(&reply->wait_q);
838 lcs_put_reply(reply);
839 return;
840 }
841 }
842 spin_unlock_irqrestore(&reply->card->lock, flags);
843}
844
845static int
846lcs_send_lancmd(struct lcs_card *card, struct lcs_buffer *buffer,
847 void (*reply_callback)(struct lcs_card *, struct lcs_cmd *))
848{
849 struct lcs_reply *reply;
850 struct lcs_cmd *cmd;
851 unsigned long flags;
852 int rc;
853
854 LCS_DBF_TEXT(4, trace, "sendcmd");
855 cmd = (struct lcs_cmd *) buffer->data;
856 cmd->return_code = 0;
857 cmd->sequence_no = card->sequence_no++;
858 reply = lcs_alloc_reply(cmd);
859 if (!reply)
860 return -ENOMEM;
861 reply->callback = reply_callback;
862 reply->card = card;
863 spin_lock_irqsave(&card->lock, flags);
864 list_add_tail(&reply->list, &card->lancmd_waiters);
865 spin_unlock_irqrestore(&card->lock, flags);
866
867 buffer->callback = lcs_release_buffer;
868 rc = lcs_ready_buffer(&card->write, buffer);
869 if (rc)
870 return rc;
871 timer_setup(&reply->timer, lcs_lancmd_timeout, 0);
872 mod_timer(&reply->timer, jiffies + HZ * card->lancmd_timeout);
873 wait_event(reply->wait_q, reply->received);
874 del_timer_sync(&reply->timer);
875 LCS_DBF_TEXT_(4, trace, "rc:%d",reply->rc);
876 rc = reply->rc;
877 lcs_put_reply(reply);
878 return rc ? -EIO : 0;
879}
880
881
882
883
884static int
885lcs_send_startup(struct lcs_card *card, __u8 initiator)
886{
887 struct lcs_buffer *buffer;
888 struct lcs_cmd *cmd;
889
890 LCS_DBF_TEXT(2, trace, "startup");
891 buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
892 cmd = (struct lcs_cmd *) buffer->data;
893 cmd->cmd_code = LCS_CMD_STARTUP;
894 cmd->initiator = initiator;
895 cmd->cmd.lcs_startup.buff_size = LCS_IOBUFFERSIZE;
896 return lcs_send_lancmd(card, buffer, NULL);
897}
898
899
900
901
902static int
903lcs_send_shutdown(struct lcs_card *card)
904{
905 struct lcs_buffer *buffer;
906 struct lcs_cmd *cmd;
907
908 LCS_DBF_TEXT(2, trace, "shutdown");
909 buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
910 cmd = (struct lcs_cmd *) buffer->data;
911 cmd->cmd_code = LCS_CMD_SHUTDOWN;
912 cmd->initiator = LCS_INITIATOR_TCPIP;
913 return lcs_send_lancmd(card, buffer, NULL);
914}
915
916
917
918
919static void
920__lcs_lanstat_cb(struct lcs_card *card, struct lcs_cmd *cmd)
921{
922 LCS_DBF_TEXT(2, trace, "statcb");
923 memcpy(card->mac, cmd->cmd.lcs_lanstat_cmd.mac_addr, LCS_MAC_LENGTH);
924}
925
926static int
927lcs_send_lanstat(struct lcs_card *card)
928{
929 struct lcs_buffer *buffer;
930 struct lcs_cmd *cmd;
931
932 LCS_DBF_TEXT(2,trace, "cmdstat");
933 buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
934 cmd = (struct lcs_cmd *) buffer->data;
935
936 cmd->cmd_code = LCS_CMD_LANSTAT;
937 cmd->initiator = LCS_INITIATOR_TCPIP;
938 cmd->cmd.lcs_std_cmd.lan_type = card->lan_type;
939 cmd->cmd.lcs_std_cmd.portno = card->portno;
940 return lcs_send_lancmd(card, buffer, __lcs_lanstat_cb);
941}
942
943
944
945
946static int
947lcs_send_stoplan(struct lcs_card *card, __u8 initiator)
948{
949 struct lcs_buffer *buffer;
950 struct lcs_cmd *cmd;
951
952 LCS_DBF_TEXT(2, trace, "cmdstpln");
953 buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
954 cmd = (struct lcs_cmd *) buffer->data;
955 cmd->cmd_code = LCS_CMD_STOPLAN;
956 cmd->initiator = initiator;
957 cmd->cmd.lcs_std_cmd.lan_type = card->lan_type;
958 cmd->cmd.lcs_std_cmd.portno = card->portno;
959 return lcs_send_lancmd(card, buffer, NULL);
960}
961
962
963
964
965static void
966__lcs_send_startlan_cb(struct lcs_card *card, struct lcs_cmd *cmd)
967{
968 LCS_DBF_TEXT(2, trace, "srtlancb");
969 card->lan_type = cmd->cmd.lcs_std_cmd.lan_type;
970 card->portno = cmd->cmd.lcs_std_cmd.portno;
971}
972
973static int
974lcs_send_startlan(struct lcs_card *card, __u8 initiator)
975{
976 struct lcs_buffer *buffer;
977 struct lcs_cmd *cmd;
978
979 LCS_DBF_TEXT(2, trace, "cmdstaln");
980 buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
981 cmd = (struct lcs_cmd *) buffer->data;
982 cmd->cmd_code = LCS_CMD_STARTLAN;
983 cmd->initiator = initiator;
984 cmd->cmd.lcs_std_cmd.lan_type = card->lan_type;
985 cmd->cmd.lcs_std_cmd.portno = card->portno;
986 return lcs_send_lancmd(card, buffer, __lcs_send_startlan_cb);
987}
988
989#ifdef CONFIG_IP_MULTICAST
990
991
992
993static int
994lcs_send_setipm(struct lcs_card *card,struct lcs_ipm_list *ipm_list)
995{
996 struct lcs_buffer *buffer;
997 struct lcs_cmd *cmd;
998
999 LCS_DBF_TEXT(2, trace, "cmdsetim");
1000 buffer = lcs_get_lancmd(card, LCS_MULTICAST_CMD_SIZE);
1001 cmd = (struct lcs_cmd *) buffer->data;
1002 cmd->cmd_code = LCS_CMD_SETIPM;
1003 cmd->initiator = LCS_INITIATOR_TCPIP;
1004 cmd->cmd.lcs_qipassist.lan_type = card->lan_type;
1005 cmd->cmd.lcs_qipassist.portno = card->portno;
1006 cmd->cmd.lcs_qipassist.version = 4;
1007 cmd->cmd.lcs_qipassist.num_ip_pairs = 1;
1008 memcpy(cmd->cmd.lcs_qipassist.lcs_ipass_ctlmsg.ip_mac_pair,
1009 &ipm_list->ipm, sizeof (struct lcs_ip_mac_pair));
1010 LCS_DBF_TEXT_(2, trace, "%x",ipm_list->ipm.ip_addr);
1011 return lcs_send_lancmd(card, buffer, NULL);
1012}
1013
1014
1015
1016
1017static int
1018lcs_send_delipm(struct lcs_card *card,struct lcs_ipm_list *ipm_list)
1019{
1020 struct lcs_buffer *buffer;
1021 struct lcs_cmd *cmd;
1022
1023 LCS_DBF_TEXT(2, trace, "cmddelim");
1024 buffer = lcs_get_lancmd(card, LCS_MULTICAST_CMD_SIZE);
1025 cmd = (struct lcs_cmd *) buffer->data;
1026 cmd->cmd_code = LCS_CMD_DELIPM;
1027 cmd->initiator = LCS_INITIATOR_TCPIP;
1028 cmd->cmd.lcs_qipassist.lan_type = card->lan_type;
1029 cmd->cmd.lcs_qipassist.portno = card->portno;
1030 cmd->cmd.lcs_qipassist.version = 4;
1031 cmd->cmd.lcs_qipassist.num_ip_pairs = 1;
1032 memcpy(cmd->cmd.lcs_qipassist.lcs_ipass_ctlmsg.ip_mac_pair,
1033 &ipm_list->ipm, sizeof (struct lcs_ip_mac_pair));
1034 LCS_DBF_TEXT_(2, trace, "%x",ipm_list->ipm.ip_addr);
1035 return lcs_send_lancmd(card, buffer, NULL);
1036}
1037
1038
1039
1040
1041static void
1042__lcs_check_multicast_cb(struct lcs_card *card, struct lcs_cmd *cmd)
1043{
1044 LCS_DBF_TEXT(2, trace, "chkmccb");
1045 card->ip_assists_supported =
1046 cmd->cmd.lcs_qipassist.ip_assists_supported;
1047 card->ip_assists_enabled =
1048 cmd->cmd.lcs_qipassist.ip_assists_enabled;
1049}
1050
1051static int
1052lcs_check_multicast_support(struct lcs_card *card)
1053{
1054 struct lcs_buffer *buffer;
1055 struct lcs_cmd *cmd;
1056 int rc;
1057
1058 LCS_DBF_TEXT(2, trace, "cmdqipa");
1059
1060 buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
1061 cmd = (struct lcs_cmd *) buffer->data;
1062 cmd->cmd_code = LCS_CMD_QIPASSIST;
1063 cmd->initiator = LCS_INITIATOR_TCPIP;
1064 cmd->cmd.lcs_qipassist.lan_type = card->lan_type;
1065 cmd->cmd.lcs_qipassist.portno = card->portno;
1066 cmd->cmd.lcs_qipassist.version = 4;
1067 cmd->cmd.lcs_qipassist.num_ip_pairs = 1;
1068 rc = lcs_send_lancmd(card, buffer, __lcs_check_multicast_cb);
1069 if (rc != 0) {
1070 pr_err("Query IPAssist failed. Assuming unsupported!\n");
1071 return -EOPNOTSUPP;
1072 }
1073 if (card->ip_assists_supported & LCS_IPASS_MULTICAST_SUPPORT)
1074 return 0;
1075 return -EOPNOTSUPP;
1076}
1077
1078
1079
1080
1081static void
1082lcs_fix_multicast_list(struct lcs_card *card)
1083{
1084 struct list_head failed_list;
1085 struct lcs_ipm_list *ipm, *tmp;
1086 unsigned long flags;
1087 int rc;
1088
1089 LCS_DBF_TEXT(4,trace, "fixipm");
1090 INIT_LIST_HEAD(&failed_list);
1091 spin_lock_irqsave(&card->ipm_lock, flags);
1092list_modified:
1093 list_for_each_entry_safe(ipm, tmp, &card->ipm_list, list){
1094 switch (ipm->ipm_state) {
1095 case LCS_IPM_STATE_SET_REQUIRED:
1096
1097
1098 list_del_init(&ipm->list);
1099 spin_unlock_irqrestore(&card->ipm_lock, flags);
1100 rc = lcs_send_setipm(card, ipm);
1101 spin_lock_irqsave(&card->ipm_lock, flags);
1102 if (rc) {
1103 pr_info("Adding multicast address failed."
1104 " Table possibly full!\n");
1105
1106
1107
1108 list_add_tail(&ipm->list, &failed_list);
1109 } else {
1110 ipm->ipm_state = LCS_IPM_STATE_ON_CARD;
1111
1112 list_add_tail(&ipm->list, &card->ipm_list);
1113 }
1114 goto list_modified;
1115 case LCS_IPM_STATE_DEL_REQUIRED:
1116 list_del(&ipm->list);
1117 spin_unlock_irqrestore(&card->ipm_lock, flags);
1118 lcs_send_delipm(card, ipm);
1119 spin_lock_irqsave(&card->ipm_lock, flags);
1120 kfree(ipm);
1121 goto list_modified;
1122 case LCS_IPM_STATE_ON_CARD:
1123 break;
1124 }
1125 }
1126
1127 list_for_each_entry_safe(ipm, tmp, &failed_list, list)
1128 list_move_tail(&ipm->list, &card->ipm_list);
1129
1130 spin_unlock_irqrestore(&card->ipm_lock, flags);
1131}
1132
1133
1134
1135
1136static void
1137lcs_get_mac_for_ipm(__be32 ipm, char *mac, struct net_device *dev)
1138{
1139 LCS_DBF_TEXT(4,trace, "getmac");
1140 ip_eth_mc_map(ipm, mac);
1141}
1142
1143
1144
1145
1146static void lcs_remove_mc_addresses(struct lcs_card *card,
1147 struct in_device *in4_dev)
1148{
1149 struct ip_mc_list *im4;
1150 struct list_head *l;
1151 struct lcs_ipm_list *ipm;
1152 unsigned long flags;
1153 char buf[MAX_ADDR_LEN];
1154
1155 LCS_DBF_TEXT(4, trace, "remmclst");
1156 spin_lock_irqsave(&card->ipm_lock, flags);
1157 list_for_each(l, &card->ipm_list) {
1158 ipm = list_entry(l, struct lcs_ipm_list, list);
1159 for (im4 = rcu_dereference(in4_dev->mc_list);
1160 im4 != NULL; im4 = rcu_dereference(im4->next_rcu)) {
1161 lcs_get_mac_for_ipm(im4->multiaddr, buf, card->dev);
1162 if ( (ipm->ipm.ip_addr == im4->multiaddr) &&
1163 (memcmp(buf, &ipm->ipm.mac_addr,
1164 LCS_MAC_LENGTH) == 0) )
1165 break;
1166 }
1167 if (im4 == NULL)
1168 ipm->ipm_state = LCS_IPM_STATE_DEL_REQUIRED;
1169 }
1170 spin_unlock_irqrestore(&card->ipm_lock, flags);
1171}
1172
1173static struct lcs_ipm_list *lcs_check_addr_entry(struct lcs_card *card,
1174 struct ip_mc_list *im4,
1175 char *buf)
1176{
1177 struct lcs_ipm_list *tmp, *ipm = NULL;
1178 struct list_head *l;
1179 unsigned long flags;
1180
1181 LCS_DBF_TEXT(4, trace, "chkmcent");
1182 spin_lock_irqsave(&card->ipm_lock, flags);
1183 list_for_each(l, &card->ipm_list) {
1184 tmp = list_entry(l, struct lcs_ipm_list, list);
1185 if ( (tmp->ipm.ip_addr == im4->multiaddr) &&
1186 (memcmp(buf, &tmp->ipm.mac_addr,
1187 LCS_MAC_LENGTH) == 0) ) {
1188 ipm = tmp;
1189 break;
1190 }
1191 }
1192 spin_unlock_irqrestore(&card->ipm_lock, flags);
1193 return ipm;
1194}
1195
1196static void lcs_set_mc_addresses(struct lcs_card *card,
1197 struct in_device *in4_dev)
1198{
1199
1200 struct ip_mc_list *im4;
1201 struct lcs_ipm_list *ipm;
1202 char buf[MAX_ADDR_LEN];
1203 unsigned long flags;
1204
1205 LCS_DBF_TEXT(4, trace, "setmclst");
1206 for (im4 = rcu_dereference(in4_dev->mc_list); im4 != NULL;
1207 im4 = rcu_dereference(im4->next_rcu)) {
1208 lcs_get_mac_for_ipm(im4->multiaddr, buf, card->dev);
1209 ipm = lcs_check_addr_entry(card, im4, buf);
1210 if (ipm != NULL)
1211 continue;
1212 ipm = kzalloc(sizeof(struct lcs_ipm_list), GFP_ATOMIC);
1213 if (ipm == NULL) {
1214 pr_info("Not enough memory to add"
1215 " new multicast entry!\n");
1216 break;
1217 }
1218 memcpy(&ipm->ipm.mac_addr, buf, LCS_MAC_LENGTH);
1219 ipm->ipm.ip_addr = im4->multiaddr;
1220 ipm->ipm_state = LCS_IPM_STATE_SET_REQUIRED;
1221 spin_lock_irqsave(&card->ipm_lock, flags);
1222 LCS_DBF_HEX(2,trace,&ipm->ipm.ip_addr,4);
1223 list_add(&ipm->list, &card->ipm_list);
1224 spin_unlock_irqrestore(&card->ipm_lock, flags);
1225 }
1226}
1227
1228static int
1229lcs_register_mc_addresses(void *data)
1230{
1231 struct lcs_card *card;
1232 struct in_device *in4_dev;
1233
1234 card = (struct lcs_card *) data;
1235
1236 if (!lcs_do_run_thread(card, LCS_SET_MC_THREAD))
1237 return 0;
1238 LCS_DBF_TEXT(4, trace, "regmulti");
1239
1240 in4_dev = in_dev_get(card->dev);
1241 if (in4_dev == NULL)
1242 goto out;
1243 rcu_read_lock();
1244 lcs_remove_mc_addresses(card,in4_dev);
1245 lcs_set_mc_addresses(card, in4_dev);
1246 rcu_read_unlock();
1247 in_dev_put(in4_dev);
1248
1249 netif_carrier_off(card->dev);
1250 netif_tx_disable(card->dev);
1251 wait_event(card->write.wait_q,
1252 (card->write.state != LCS_CH_STATE_RUNNING));
1253 lcs_fix_multicast_list(card);
1254 if (card->state == DEV_STATE_UP) {
1255 netif_carrier_on(card->dev);
1256 netif_wake_queue(card->dev);
1257 }
1258out:
1259 lcs_clear_thread_running_bit(card, LCS_SET_MC_THREAD);
1260 return 0;
1261}
1262#endif
1263
1264
1265
1266
1267
1268static void
1269lcs_set_multicast_list(struct net_device *dev)
1270{
1271#ifdef CONFIG_IP_MULTICAST
1272 struct lcs_card *card;
1273
1274 LCS_DBF_TEXT(4, trace, "setmulti");
1275 card = (struct lcs_card *) dev->ml_priv;
1276
1277 if (!lcs_set_thread_start_bit(card, LCS_SET_MC_THREAD))
1278 schedule_work(&card->kernel_thread_starter);
1279#endif
1280}
1281
1282static long
1283lcs_check_irb_error(struct ccw_device *cdev, struct irb *irb)
1284{
1285 if (!IS_ERR(irb))
1286 return 0;
1287
1288 switch (PTR_ERR(irb)) {
1289 case -EIO:
1290 dev_warn(&cdev->dev,
1291 "An I/O-error occurred on the LCS device\n");
1292 LCS_DBF_TEXT(2, trace, "ckirberr");
1293 LCS_DBF_TEXT_(2, trace, " rc%d", -EIO);
1294 break;
1295 case -ETIMEDOUT:
1296 dev_warn(&cdev->dev,
1297 "A command timed out on the LCS device\n");
1298 LCS_DBF_TEXT(2, trace, "ckirberr");
1299 LCS_DBF_TEXT_(2, trace, " rc%d", -ETIMEDOUT);
1300 break;
1301 default:
1302 dev_warn(&cdev->dev,
1303 "An error occurred on the LCS device, rc=%ld\n",
1304 PTR_ERR(irb));
1305 LCS_DBF_TEXT(2, trace, "ckirberr");
1306 LCS_DBF_TEXT(2, trace, " rc???");
1307 }
1308 return PTR_ERR(irb);
1309}
1310
1311static int
1312lcs_get_problem(struct ccw_device *cdev, struct irb *irb)
1313{
1314 int dstat, cstat;
1315 char *sense;
1316
1317 sense = (char *) irb->ecw;
1318 cstat = irb->scsw.cmd.cstat;
1319 dstat = irb->scsw.cmd.dstat;
1320
1321 if (cstat & (SCHN_STAT_CHN_CTRL_CHK | SCHN_STAT_INTF_CTRL_CHK |
1322 SCHN_STAT_CHN_DATA_CHK | SCHN_STAT_CHAIN_CHECK |
1323 SCHN_STAT_PROT_CHECK | SCHN_STAT_PROG_CHECK)) {
1324 LCS_DBF_TEXT(2, trace, "CGENCHK");
1325 return 1;
1326 }
1327 if (dstat & DEV_STAT_UNIT_CHECK) {
1328 if (sense[LCS_SENSE_BYTE_1] &
1329 LCS_SENSE_RESETTING_EVENT) {
1330 LCS_DBF_TEXT(2, trace, "REVIND");
1331 return 1;
1332 }
1333 if (sense[LCS_SENSE_BYTE_0] &
1334 LCS_SENSE_CMD_REJECT) {
1335 LCS_DBF_TEXT(2, trace, "CMDREJ");
1336 return 0;
1337 }
1338 if ((!sense[LCS_SENSE_BYTE_0]) &&
1339 (!sense[LCS_SENSE_BYTE_1]) &&
1340 (!sense[LCS_SENSE_BYTE_2]) &&
1341 (!sense[LCS_SENSE_BYTE_3])) {
1342 LCS_DBF_TEXT(2, trace, "ZEROSEN");
1343 return 0;
1344 }
1345 LCS_DBF_TEXT(2, trace, "DGENCHK");
1346 return 1;
1347 }
1348 return 0;
1349}
1350
1351static void
1352lcs_schedule_recovery(struct lcs_card *card)
1353{
1354 LCS_DBF_TEXT(2, trace, "startrec");
1355 if (!lcs_set_thread_start_bit(card, LCS_RECOVERY_THREAD))
1356 schedule_work(&card->kernel_thread_starter);
1357}
1358
1359
1360
1361
1362static void
1363lcs_irq(struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
1364{
1365 struct lcs_card *card;
1366 struct lcs_channel *channel;
1367 int rc, index;
1368 int cstat, dstat;
1369
1370 if (lcs_check_irb_error(cdev, irb))
1371 return;
1372
1373 card = CARD_FROM_DEV(cdev);
1374 if (card->read.ccwdev == cdev)
1375 channel = &card->read;
1376 else
1377 channel = &card->write;
1378
1379 cstat = irb->scsw.cmd.cstat;
1380 dstat = irb->scsw.cmd.dstat;
1381 LCS_DBF_TEXT_(5, trace, "Rint%s", dev_name(&cdev->dev));
1382 LCS_DBF_TEXT_(5, trace, "%4x%4x", irb->scsw.cmd.cstat,
1383 irb->scsw.cmd.dstat);
1384 LCS_DBF_TEXT_(5, trace, "%4x%4x", irb->scsw.cmd.fctl,
1385 irb->scsw.cmd.actl);
1386
1387
1388 rc = lcs_get_problem(cdev, irb);
1389 if (rc || (dstat & DEV_STAT_UNIT_EXCEP)) {
1390 dev_warn(&cdev->dev,
1391 "The LCS device stopped because of an error,"
1392 " dstat=0x%X, cstat=0x%X \n",
1393 dstat, cstat);
1394 if (rc) {
1395 channel->state = LCS_CH_STATE_ERROR;
1396 }
1397 }
1398 if (channel->state == LCS_CH_STATE_ERROR) {
1399 lcs_schedule_recovery(card);
1400 wake_up(&card->wait_q);
1401 return;
1402 }
1403
1404 if ((channel->state != LCS_CH_STATE_INIT) &&
1405 (irb->scsw.cmd.fctl & SCSW_FCTL_START_FUNC) &&
1406 (irb->scsw.cmd.cpa != 0)) {
1407 index = (struct ccw1 *) __va((addr_t) irb->scsw.cmd.cpa)
1408 - channel->ccws;
1409 if ((irb->scsw.cmd.actl & SCSW_ACTL_SUSPENDED) ||
1410 (irb->scsw.cmd.cstat & SCHN_STAT_PCI))
1411
1412 index = (index - 1) & (LCS_NUM_BUFFS - 1);
1413 while (channel->io_idx != index) {
1414 __lcs_processed_buffer(channel,
1415 channel->iob + channel->io_idx);
1416 channel->io_idx =
1417 (channel->io_idx + 1) & (LCS_NUM_BUFFS - 1);
1418 }
1419 }
1420
1421 if ((irb->scsw.cmd.dstat & DEV_STAT_DEV_END) ||
1422 (irb->scsw.cmd.dstat & DEV_STAT_CHN_END) ||
1423 (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK))
1424
1425 channel->state = LCS_CH_STATE_STOPPED;
1426 else if (irb->scsw.cmd.actl & SCSW_ACTL_SUSPENDED)
1427
1428 channel->state = LCS_CH_STATE_SUSPENDED;
1429 if (irb->scsw.cmd.fctl & SCSW_FCTL_HALT_FUNC) {
1430 if (irb->scsw.cmd.cc != 0) {
1431 ccw_device_halt(channel->ccwdev, 0);
1432 return;
1433 }
1434
1435 channel->state = LCS_CH_STATE_HALTED;
1436 }
1437 if (irb->scsw.cmd.fctl & SCSW_FCTL_CLEAR_FUNC)
1438 channel->state = LCS_CH_STATE_CLEARED;
1439
1440 tasklet_schedule(&channel->irq_tasklet);
1441}
1442
1443
1444
1445
1446static void
1447lcs_tasklet(unsigned long data)
1448{
1449 unsigned long flags;
1450 struct lcs_channel *channel;
1451 struct lcs_buffer *iob;
1452 int buf_idx;
1453
1454 channel = (struct lcs_channel *) data;
1455 LCS_DBF_TEXT_(5, trace, "tlet%s", dev_name(&channel->ccwdev->dev));
1456
1457
1458 iob = channel->iob;
1459 buf_idx = channel->buf_idx;
1460 while (iob[buf_idx].state == LCS_BUF_STATE_PROCESSED) {
1461
1462 if (iob[buf_idx].callback != NULL)
1463 iob[buf_idx].callback(channel, iob + buf_idx);
1464 buf_idx = (buf_idx + 1) & (LCS_NUM_BUFFS - 1);
1465 }
1466 channel->buf_idx = buf_idx;
1467
1468 if (channel->state == LCS_CH_STATE_STOPPED)
1469 lcs_start_channel(channel);
1470 spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
1471 if (channel->state == LCS_CH_STATE_SUSPENDED &&
1472 channel->iob[channel->io_idx].state == LCS_BUF_STATE_READY)
1473 __lcs_resume_channel(channel);
1474 spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
1475
1476
1477 wake_up(&channel->wait_q);
1478}
1479
1480
1481
1482
1483static void
1484__lcs_emit_txbuffer(struct lcs_card *card)
1485{
1486 LCS_DBF_TEXT(5, trace, "emittx");
1487 *(__u16 *)(card->tx_buffer->data + card->tx_buffer->count) = 0;
1488 card->tx_buffer->count += 2;
1489 lcs_ready_buffer(&card->write, card->tx_buffer);
1490 card->tx_buffer = NULL;
1491 card->tx_emitted++;
1492}
1493
1494
1495
1496
1497static void
1498lcs_txbuffer_cb(struct lcs_channel *channel, struct lcs_buffer *buffer)
1499{
1500 struct lcs_card *card;
1501
1502 LCS_DBF_TEXT(5, trace, "txbuffcb");
1503
1504 lcs_release_buffer(channel, buffer);
1505 card = container_of(channel, struct lcs_card, write);
1506 if (netif_queue_stopped(card->dev) && netif_carrier_ok(card->dev))
1507 netif_wake_queue(card->dev);
1508 spin_lock(&card->lock);
1509 card->tx_emitted--;
1510 if (card->tx_emitted <= 0 && card->tx_buffer != NULL)
1511
1512
1513
1514
1515 __lcs_emit_txbuffer(card);
1516 spin_unlock(&card->lock);
1517}
1518
1519
1520
1521
1522static int
1523__lcs_start_xmit(struct lcs_card *card, struct sk_buff *skb,
1524 struct net_device *dev)
1525{
1526 struct lcs_header *header;
1527 int rc = NETDEV_TX_OK;
1528
1529 LCS_DBF_TEXT(5, trace, "hardxmit");
1530 if (skb == NULL) {
1531 card->stats.tx_dropped++;
1532 card->stats.tx_errors++;
1533 return NETDEV_TX_OK;
1534 }
1535 if (card->state != DEV_STATE_UP) {
1536 dev_kfree_skb(skb);
1537 card->stats.tx_dropped++;
1538 card->stats.tx_errors++;
1539 card->stats.tx_carrier_errors++;
1540 return NETDEV_TX_OK;
1541 }
1542 if (skb->protocol == htons(ETH_P_IPV6)) {
1543 dev_kfree_skb(skb);
1544 return NETDEV_TX_OK;
1545 }
1546 netif_stop_queue(card->dev);
1547 spin_lock(&card->lock);
1548 if (card->tx_buffer != NULL &&
1549 card->tx_buffer->count + sizeof(struct lcs_header) +
1550 skb->len + sizeof(u16) > LCS_IOBUFFERSIZE)
1551
1552 __lcs_emit_txbuffer(card);
1553 if (card->tx_buffer == NULL) {
1554
1555 card->tx_buffer = lcs_get_buffer(&card->write);
1556 if (card->tx_buffer == NULL) {
1557 card->stats.tx_dropped++;
1558 rc = NETDEV_TX_BUSY;
1559 goto out;
1560 }
1561 card->tx_buffer->callback = lcs_txbuffer_cb;
1562 card->tx_buffer->count = 0;
1563 }
1564 header = (struct lcs_header *)
1565 (card->tx_buffer->data + card->tx_buffer->count);
1566 card->tx_buffer->count += skb->len + sizeof(struct lcs_header);
1567 header->offset = card->tx_buffer->count;
1568 header->type = card->lan_type;
1569 header->slot = card->portno;
1570 skb_copy_from_linear_data(skb, header + 1, skb->len);
1571 spin_unlock(&card->lock);
1572 card->stats.tx_bytes += skb->len;
1573 card->stats.tx_packets++;
1574 dev_kfree_skb(skb);
1575 netif_wake_queue(card->dev);
1576 spin_lock(&card->lock);
1577 if (card->tx_emitted <= 0 && card->tx_buffer != NULL)
1578
1579 __lcs_emit_txbuffer(card);
1580out:
1581 spin_unlock(&card->lock);
1582 return rc;
1583}
1584
1585static int
1586lcs_start_xmit(struct sk_buff *skb, struct net_device *dev)
1587{
1588 struct lcs_card *card;
1589 int rc;
1590
1591 LCS_DBF_TEXT(5, trace, "pktxmit");
1592 card = (struct lcs_card *) dev->ml_priv;
1593 rc = __lcs_start_xmit(card, skb, dev);
1594 return rc;
1595}
1596
1597
1598
1599
1600static int
1601lcs_startlan_auto(struct lcs_card *card)
1602{
1603 int rc;
1604
1605 LCS_DBF_TEXT(2, trace, "strtauto");
1606#ifdef CONFIG_ETHERNET
1607 card->lan_type = LCS_FRAME_TYPE_ENET;
1608 rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP);
1609 if (rc == 0)
1610 return 0;
1611
1612#endif
1613#ifdef CONFIG_FDDI
1614 card->lan_type = LCS_FRAME_TYPE_FDDI;
1615 rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP);
1616 if (rc == 0)
1617 return 0;
1618#endif
1619 return -EIO;
1620}
1621
1622static int
1623lcs_startlan(struct lcs_card *card)
1624{
1625 int rc, i;
1626
1627 LCS_DBF_TEXT(2, trace, "startlan");
1628 rc = 0;
1629 if (card->portno != LCS_INVALID_PORT_NO) {
1630 if (card->lan_type == LCS_FRAME_TYPE_AUTO)
1631 rc = lcs_startlan_auto(card);
1632 else
1633 rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP);
1634 } else {
1635 for (i = 0; i <= 16; i++) {
1636 card->portno = i;
1637 if (card->lan_type != LCS_FRAME_TYPE_AUTO)
1638 rc = lcs_send_startlan(card,
1639 LCS_INITIATOR_TCPIP);
1640 else
1641
1642 rc = lcs_startlan_auto(card);
1643 if (rc == 0)
1644 break;
1645 }
1646 }
1647 if (rc == 0)
1648 return lcs_send_lanstat(card);
1649 return rc;
1650}
1651
1652
1653
1654
1655
1656static int
1657lcs_detect(struct lcs_card *card)
1658{
1659 int rc = 0;
1660
1661 LCS_DBF_TEXT(2, setup, "lcsdetct");
1662
1663 if (card->dev)
1664 netif_stop_queue(card->dev);
1665 rc = lcs_stop_channels(card);
1666 if (rc == 0) {
1667 rc = lcs_start_channels(card);
1668 if (rc == 0) {
1669 rc = lcs_send_startup(card, LCS_INITIATOR_TCPIP);
1670 if (rc == 0)
1671 rc = lcs_startlan(card);
1672 }
1673 }
1674 if (rc == 0) {
1675 card->state = DEV_STATE_UP;
1676 } else {
1677 card->state = DEV_STATE_DOWN;
1678 card->write.state = LCS_CH_STATE_INIT;
1679 card->read.state = LCS_CH_STATE_INIT;
1680 }
1681 return rc;
1682}
1683
1684
1685
1686
1687static int
1688lcs_stopcard(struct lcs_card *card)
1689{
1690 int rc;
1691
1692 LCS_DBF_TEXT(3, setup, "stopcard");
1693
1694 if (card->read.state != LCS_CH_STATE_STOPPED &&
1695 card->write.state != LCS_CH_STATE_STOPPED &&
1696 card->read.state != LCS_CH_STATE_ERROR &&
1697 card->write.state != LCS_CH_STATE_ERROR &&
1698 card->state == DEV_STATE_UP) {
1699 lcs_clear_multicast_list(card);
1700 rc = lcs_send_stoplan(card,LCS_INITIATOR_TCPIP);
1701 rc = lcs_send_shutdown(card);
1702 }
1703 rc = lcs_stop_channels(card);
1704 card->state = DEV_STATE_DOWN;
1705
1706 return rc;
1707}
1708
1709
1710
1711
1712static void
1713lcs_start_kernel_thread(struct work_struct *work)
1714{
1715 struct lcs_card *card = container_of(work, struct lcs_card, kernel_thread_starter);
1716 LCS_DBF_TEXT(5, trace, "krnthrd");
1717 if (lcs_do_start_thread(card, LCS_RECOVERY_THREAD))
1718 kthread_run(lcs_recovery, card, "lcs_recover");
1719#ifdef CONFIG_IP_MULTICAST
1720 if (lcs_do_start_thread(card, LCS_SET_MC_THREAD))
1721 kthread_run(lcs_register_mc_addresses, card, "regipm");
1722#endif
1723}
1724
1725
1726
1727
1728static void
1729lcs_get_control(struct lcs_card *card, struct lcs_cmd *cmd)
1730{
1731 LCS_DBF_TEXT(5, trace, "getctrl");
1732 if (cmd->initiator == LCS_INITIATOR_LGW) {
1733 switch(cmd->cmd_code) {
1734 case LCS_CMD_STARTUP:
1735 case LCS_CMD_STARTLAN:
1736 lcs_schedule_recovery(card);
1737 break;
1738 case LCS_CMD_STOPLAN:
1739 pr_warn("Stoplan for %s initiated by LGW\n",
1740 card->dev->name);
1741 if (card->dev)
1742 netif_carrier_off(card->dev);
1743 break;
1744 default:
1745 LCS_DBF_TEXT(5, trace, "noLGWcmd");
1746 break;
1747 }
1748 } else
1749 lcs_notify_lancmd_waiters(card, cmd);
1750}
1751
1752
1753
1754
1755static void
1756lcs_get_skb(struct lcs_card *card, char *skb_data, unsigned int skb_len)
1757{
1758 struct sk_buff *skb;
1759
1760 LCS_DBF_TEXT(5, trace, "getskb");
1761 if (card->dev == NULL ||
1762 card->state != DEV_STATE_UP)
1763
1764 return;
1765
1766 skb = dev_alloc_skb(skb_len);
1767 if (skb == NULL) {
1768 dev_err(&card->dev->dev,
1769 " Allocating a socket buffer to interface %s failed\n",
1770 card->dev->name);
1771 card->stats.rx_dropped++;
1772 return;
1773 }
1774 skb_put_data(skb, skb_data, skb_len);
1775 skb->protocol = card->lan_type_trans(skb, card->dev);
1776 card->stats.rx_bytes += skb_len;
1777 card->stats.rx_packets++;
1778 if (skb->protocol == htons(ETH_P_802_2))
1779 *((__u32 *)skb->cb) = ++card->pkt_seq;
1780 netif_rx(skb);
1781}
1782
1783
1784
1785
1786static void
1787lcs_get_frames_cb(struct lcs_channel *channel, struct lcs_buffer *buffer)
1788{
1789 struct lcs_card *card;
1790 struct lcs_header *lcs_hdr;
1791 __u16 offset;
1792
1793 LCS_DBF_TEXT(5, trace, "lcsgtpkt");
1794 lcs_hdr = (struct lcs_header *) buffer->data;
1795 if (lcs_hdr->offset == LCS_ILLEGAL_OFFSET) {
1796 LCS_DBF_TEXT(4, trace, "-eiogpkt");
1797 return;
1798 }
1799 card = container_of(channel, struct lcs_card, read);
1800 offset = 0;
1801 while (lcs_hdr->offset != 0) {
1802 if (lcs_hdr->offset <= 0 ||
1803 lcs_hdr->offset > LCS_IOBUFFERSIZE ||
1804 lcs_hdr->offset < offset) {
1805
1806 card->stats.rx_length_errors++;
1807 card->stats.rx_errors++;
1808 return;
1809 }
1810
1811 if (lcs_hdr->type == LCS_FRAME_TYPE_CONTROL) {
1812
1813 lcs_get_control(card, (struct lcs_cmd *) lcs_hdr);
1814 } else if (lcs_hdr->type == LCS_FRAME_TYPE_ENET ||
1815 lcs_hdr->type == LCS_FRAME_TYPE_TR ||
1816 lcs_hdr->type == LCS_FRAME_TYPE_FDDI) {
1817
1818 lcs_get_skb(card, (char *)(lcs_hdr + 1),
1819 lcs_hdr->offset - offset -
1820 sizeof(struct lcs_header));
1821 } else {
1822
1823 ;
1824 }
1825
1826 offset = lcs_hdr->offset;
1827 lcs_hdr->offset = LCS_ILLEGAL_OFFSET;
1828 lcs_hdr = (struct lcs_header *) (buffer->data + offset);
1829 }
1830
1831 lcs_ready_buffer(&card->read, buffer);
1832}
1833
1834
1835
1836
1837static struct net_device_stats *
1838lcs_getstats(struct net_device *dev)
1839{
1840 struct lcs_card *card;
1841
1842 LCS_DBF_TEXT(4, trace, "netstats");
1843 card = (struct lcs_card *) dev->ml_priv;
1844 return &card->stats;
1845}
1846
1847
1848
1849
1850
1851static int
1852lcs_stop_device(struct net_device *dev)
1853{
1854 struct lcs_card *card;
1855 int rc;
1856
1857 LCS_DBF_TEXT(2, trace, "stopdev");
1858 card = (struct lcs_card *) dev->ml_priv;
1859 netif_carrier_off(dev);
1860 netif_tx_disable(dev);
1861 dev->flags &= ~IFF_UP;
1862 wait_event(card->write.wait_q,
1863 (card->write.state != LCS_CH_STATE_RUNNING));
1864 rc = lcs_stopcard(card);
1865 if (rc)
1866 dev_err(&card->dev->dev,
1867 " Shutting down the LCS device failed\n");
1868 return rc;
1869}
1870
1871
1872
1873
1874
1875static int
1876lcs_open_device(struct net_device *dev)
1877{
1878 struct lcs_card *card;
1879 int rc;
1880
1881 LCS_DBF_TEXT(2, trace, "opendev");
1882 card = (struct lcs_card *) dev->ml_priv;
1883
1884 rc = lcs_detect(card);
1885 if (rc) {
1886 pr_err("Error in opening device!\n");
1887
1888 } else {
1889 dev->flags |= IFF_UP;
1890 netif_carrier_on(dev);
1891 netif_wake_queue(dev);
1892 card->state = DEV_STATE_UP;
1893 }
1894 return rc;
1895}
1896
1897
1898
1899
1900static ssize_t
1901lcs_portno_show (struct device *dev, struct device_attribute *attr, char *buf)
1902{
1903 struct lcs_card *card;
1904
1905 card = dev_get_drvdata(dev);
1906
1907 if (!card)
1908 return 0;
1909
1910 return sprintf(buf, "%d\n", card->portno);
1911}
1912
1913
1914
1915
1916static ssize_t
1917lcs_portno_store (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1918{
1919 struct lcs_card *card;
1920 int rc;
1921 s16 value;
1922
1923 card = dev_get_drvdata(dev);
1924
1925 if (!card)
1926 return 0;
1927
1928 rc = kstrtos16(buf, 0, &value);
1929 if (rc)
1930 return -EINVAL;
1931
1932 card->portno = value;
1933 if (card->dev)
1934 card->dev->dev_port = card->portno;
1935
1936 return count;
1937
1938}
1939
1940static DEVICE_ATTR(portno, 0644, lcs_portno_show, lcs_portno_store);
1941
1942static const char *lcs_type[] = {
1943 "not a channel",
1944 "2216 parallel",
1945 "2216 channel",
1946 "OSA LCS card",
1947 "unknown channel type",
1948 "unsupported channel type",
1949};
1950
1951static ssize_t
1952lcs_type_show(struct device *dev, struct device_attribute *attr, char *buf)
1953{
1954 struct ccwgroup_device *cgdev;
1955
1956 cgdev = to_ccwgroupdev(dev);
1957 if (!cgdev)
1958 return -ENODEV;
1959
1960 return sprintf(buf, "%s\n", lcs_type[cgdev->cdev[0]->id.driver_info]);
1961}
1962
1963static DEVICE_ATTR(type, 0444, lcs_type_show, NULL);
1964
1965static ssize_t
1966lcs_timeout_show(struct device *dev, struct device_attribute *attr, char *buf)
1967{
1968 struct lcs_card *card;
1969
1970 card = dev_get_drvdata(dev);
1971
1972 return card ? sprintf(buf, "%u\n", card->lancmd_timeout) : 0;
1973}
1974
1975static ssize_t
1976lcs_timeout_store (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1977{
1978 struct lcs_card *card;
1979 unsigned int value;
1980 int rc;
1981
1982 card = dev_get_drvdata(dev);
1983
1984 if (!card)
1985 return 0;
1986
1987 rc = kstrtouint(buf, 0, &value);
1988 if (rc)
1989 return -EINVAL;
1990
1991 card->lancmd_timeout = value;
1992
1993 return count;
1994
1995}
1996
1997static DEVICE_ATTR(lancmd_timeout, 0644, lcs_timeout_show, lcs_timeout_store);
1998
1999static ssize_t
2000lcs_dev_recover_store(struct device *dev, struct device_attribute *attr,
2001 const char *buf, size_t count)
2002{
2003 struct lcs_card *card = dev_get_drvdata(dev);
2004 char *tmp;
2005 int i;
2006
2007 if (!card)
2008 return -EINVAL;
2009 if (card->state != DEV_STATE_UP)
2010 return -EPERM;
2011 i = simple_strtoul(buf, &tmp, 16);
2012 if (i == 1)
2013 lcs_schedule_recovery(card);
2014 return count;
2015}
2016
2017static DEVICE_ATTR(recover, 0200, NULL, lcs_dev_recover_store);
2018
2019static struct attribute * lcs_attrs[] = {
2020 &dev_attr_portno.attr,
2021 &dev_attr_type.attr,
2022 &dev_attr_lancmd_timeout.attr,
2023 &dev_attr_recover.attr,
2024 NULL,
2025};
2026static struct attribute_group lcs_attr_group = {
2027 .attrs = lcs_attrs,
2028};
2029static const struct attribute_group *lcs_attr_groups[] = {
2030 &lcs_attr_group,
2031 NULL,
2032};
2033static const struct device_type lcs_devtype = {
2034 .name = "lcs",
2035 .groups = lcs_attr_groups,
2036};
2037
2038
2039
2040
2041static int
2042lcs_probe_device(struct ccwgroup_device *ccwgdev)
2043{
2044 struct lcs_card *card;
2045
2046 if (!get_device(&ccwgdev->dev))
2047 return -ENODEV;
2048
2049 LCS_DBF_TEXT(2, setup, "add_dev");
2050 card = lcs_alloc_card();
2051 if (!card) {
2052 LCS_DBF_TEXT_(2, setup, " rc%d", -ENOMEM);
2053 put_device(&ccwgdev->dev);
2054 return -ENOMEM;
2055 }
2056 dev_set_drvdata(&ccwgdev->dev, card);
2057 ccwgdev->cdev[0]->handler = lcs_irq;
2058 ccwgdev->cdev[1]->handler = lcs_irq;
2059 card->gdev = ccwgdev;
2060 INIT_WORK(&card->kernel_thread_starter, lcs_start_kernel_thread);
2061 card->thread_start_mask = 0;
2062 card->thread_allowed_mask = 0;
2063 card->thread_running_mask = 0;
2064 ccwgdev->dev.type = &lcs_devtype;
2065
2066 return 0;
2067}
2068
2069static int
2070lcs_register_netdev(struct ccwgroup_device *ccwgdev)
2071{
2072 struct lcs_card *card;
2073
2074 LCS_DBF_TEXT(2, setup, "regnetdv");
2075 card = dev_get_drvdata(&ccwgdev->dev);
2076 if (card->dev->reg_state != NETREG_UNINITIALIZED)
2077 return 0;
2078 SET_NETDEV_DEV(card->dev, &ccwgdev->dev);
2079 return register_netdev(card->dev);
2080}
2081
2082
2083
2084
2085static const struct net_device_ops lcs_netdev_ops = {
2086 .ndo_open = lcs_open_device,
2087 .ndo_stop = lcs_stop_device,
2088 .ndo_get_stats = lcs_getstats,
2089 .ndo_start_xmit = lcs_start_xmit,
2090};
2091
2092static const struct net_device_ops lcs_mc_netdev_ops = {
2093 .ndo_open = lcs_open_device,
2094 .ndo_stop = lcs_stop_device,
2095 .ndo_get_stats = lcs_getstats,
2096 .ndo_start_xmit = lcs_start_xmit,
2097 .ndo_set_rx_mode = lcs_set_multicast_list,
2098};
2099
2100static int
2101lcs_new_device(struct ccwgroup_device *ccwgdev)
2102{
2103 struct lcs_card *card;
2104 struct net_device *dev=NULL;
2105 enum lcs_dev_states recover_state;
2106 int rc;
2107
2108 card = dev_get_drvdata(&ccwgdev->dev);
2109 if (!card)
2110 return -ENODEV;
2111
2112 LCS_DBF_TEXT(2, setup, "newdev");
2113 LCS_DBF_HEX(3, setup, &card, sizeof(void*));
2114 card->read.ccwdev = ccwgdev->cdev[0];
2115 card->write.ccwdev = ccwgdev->cdev[1];
2116
2117 recover_state = card->state;
2118 rc = ccw_device_set_online(card->read.ccwdev);
2119 if (rc)
2120 goto out_err;
2121 rc = ccw_device_set_online(card->write.ccwdev);
2122 if (rc)
2123 goto out_werr;
2124
2125 LCS_DBF_TEXT(3, setup, "lcsnewdv");
2126
2127 lcs_setup_card(card);
2128 rc = lcs_detect(card);
2129 if (rc) {
2130 LCS_DBF_TEXT(2, setup, "dtctfail");
2131 dev_err(&ccwgdev->dev,
2132 "Detecting a network adapter for LCS devices"
2133 " failed with rc=%d (0x%x)\n", rc, rc);
2134 lcs_stopcard(card);
2135 goto out;
2136 }
2137 if (card->dev) {
2138 LCS_DBF_TEXT(2, setup, "samedev");
2139 LCS_DBF_HEX(3, setup, &card, sizeof(void*));
2140 goto netdev_out;
2141 }
2142 switch (card->lan_type) {
2143#ifdef CONFIG_ETHERNET
2144 case LCS_FRAME_TYPE_ENET:
2145 card->lan_type_trans = eth_type_trans;
2146 dev = alloc_etherdev(0);
2147 break;
2148#endif
2149#ifdef CONFIG_FDDI
2150 case LCS_FRAME_TYPE_FDDI:
2151 card->lan_type_trans = fddi_type_trans;
2152 dev = alloc_fddidev(0);
2153 break;
2154#endif
2155 default:
2156 LCS_DBF_TEXT(3, setup, "errinit");
2157 pr_err(" Initialization failed\n");
2158 goto out;
2159 }
2160 if (!dev)
2161 goto out;
2162 card->dev = dev;
2163 card->dev->ml_priv = card;
2164 card->dev->netdev_ops = &lcs_netdev_ops;
2165 card->dev->dev_port = card->portno;
2166 eth_hw_addr_set(card->dev, card->mac);
2167#ifdef CONFIG_IP_MULTICAST
2168 if (!lcs_check_multicast_support(card))
2169 card->dev->netdev_ops = &lcs_mc_netdev_ops;
2170#endif
2171netdev_out:
2172 lcs_set_allowed_threads(card,0xffffffff);
2173 if (recover_state == DEV_STATE_RECOVER) {
2174 lcs_set_multicast_list(card->dev);
2175 card->dev->flags |= IFF_UP;
2176 netif_carrier_on(card->dev);
2177 netif_wake_queue(card->dev);
2178 card->state = DEV_STATE_UP;
2179 } else {
2180 lcs_stopcard(card);
2181 }
2182
2183 if (lcs_register_netdev(ccwgdev) != 0)
2184 goto out;
2185
2186
2187 pr_info("LCS device %s %s IPv6 support\n", card->dev->name,
2188 (card->ip_assists_supported & LCS_IPASS_IPV6_SUPPORT) ?
2189 "with" : "without");
2190
2191 pr_info("LCS device %s %s Multicast support\n", card->dev->name,
2192 (card->ip_assists_supported & LCS_IPASS_MULTICAST_SUPPORT) ?
2193 "with" : "without");
2194 return 0;
2195out:
2196
2197 ccw_device_set_offline(card->write.ccwdev);
2198out_werr:
2199 ccw_device_set_offline(card->read.ccwdev);
2200out_err:
2201 return -ENODEV;
2202}
2203
2204
2205
2206
2207static int
2208__lcs_shutdown_device(struct ccwgroup_device *ccwgdev, int recovery_mode)
2209{
2210 struct lcs_card *card;
2211 enum lcs_dev_states recover_state;
2212 int ret = 0, ret2 = 0, ret3 = 0;
2213
2214 LCS_DBF_TEXT(3, setup, "shtdndev");
2215 card = dev_get_drvdata(&ccwgdev->dev);
2216 if (!card)
2217 return -ENODEV;
2218 if (recovery_mode == 0) {
2219 lcs_set_allowed_threads(card, 0);
2220 if (lcs_wait_for_threads(card, LCS_SET_MC_THREAD))
2221 return -ERESTARTSYS;
2222 }
2223 LCS_DBF_HEX(3, setup, &card, sizeof(void*));
2224 recover_state = card->state;
2225
2226 ret = lcs_stop_device(card->dev);
2227 ret2 = ccw_device_set_offline(card->read.ccwdev);
2228 ret3 = ccw_device_set_offline(card->write.ccwdev);
2229 if (!ret)
2230 ret = (ret2) ? ret2 : ret3;
2231 if (ret)
2232 LCS_DBF_TEXT_(3, setup, "1err:%d", ret);
2233 if (recover_state == DEV_STATE_UP) {
2234 card->state = DEV_STATE_RECOVER;
2235 }
2236 return 0;
2237}
2238
2239static int
2240lcs_shutdown_device(struct ccwgroup_device *ccwgdev)
2241{
2242 return __lcs_shutdown_device(ccwgdev, 0);
2243}
2244
2245
2246
2247
2248static int
2249lcs_recovery(void *ptr)
2250{
2251 struct lcs_card *card;
2252 struct ccwgroup_device *gdev;
2253 int rc;
2254
2255 card = (struct lcs_card *) ptr;
2256
2257 LCS_DBF_TEXT(4, trace, "recover1");
2258 if (!lcs_do_run_thread(card, LCS_RECOVERY_THREAD))
2259 return 0;
2260 LCS_DBF_TEXT(4, trace, "recover2");
2261 gdev = card->gdev;
2262 dev_warn(&gdev->dev,
2263 "A recovery process has been started for the LCS device\n");
2264 rc = __lcs_shutdown_device(gdev, 1);
2265 rc = lcs_new_device(gdev);
2266 if (!rc)
2267 pr_info("Device %s successfully recovered!\n",
2268 card->dev->name);
2269 else
2270 pr_info("Device %s could not be recovered!\n",
2271 card->dev->name);
2272 lcs_clear_thread_running_bit(card, LCS_RECOVERY_THREAD);
2273 return 0;
2274}
2275
2276
2277
2278
2279static void
2280lcs_remove_device(struct ccwgroup_device *ccwgdev)
2281{
2282 struct lcs_card *card;
2283
2284 card = dev_get_drvdata(&ccwgdev->dev);
2285 if (!card)
2286 return;
2287
2288 LCS_DBF_TEXT(3, setup, "remdev");
2289 LCS_DBF_HEX(3, setup, &card, sizeof(void*));
2290 if (ccwgdev->state == CCWGROUP_ONLINE) {
2291 lcs_shutdown_device(ccwgdev);
2292 }
2293 if (card->dev)
2294 unregister_netdev(card->dev);
2295 lcs_cleanup_card(card);
2296 lcs_free_card(card);
2297 dev_set_drvdata(&ccwgdev->dev, NULL);
2298 put_device(&ccwgdev->dev);
2299}
2300
2301static struct ccw_device_id lcs_ids[] = {
2302 {CCW_DEVICE(0x3088, 0x08), .driver_info = lcs_channel_type_parallel},
2303 {CCW_DEVICE(0x3088, 0x1f), .driver_info = lcs_channel_type_2216},
2304 {CCW_DEVICE(0x3088, 0x60), .driver_info = lcs_channel_type_osa2},
2305 {},
2306};
2307MODULE_DEVICE_TABLE(ccw, lcs_ids);
2308
2309static struct ccw_driver lcs_ccw_driver = {
2310 .driver = {
2311 .owner = THIS_MODULE,
2312 .name = "lcs",
2313 },
2314 .ids = lcs_ids,
2315 .probe = ccwgroup_probe_ccwdev,
2316 .remove = ccwgroup_remove_ccwdev,
2317 .int_class = IRQIO_LCS,
2318};
2319
2320
2321
2322
2323static struct ccwgroup_driver lcs_group_driver = {
2324 .driver = {
2325 .owner = THIS_MODULE,
2326 .name = "lcs",
2327 },
2328 .ccw_driver = &lcs_ccw_driver,
2329 .setup = lcs_probe_device,
2330 .remove = lcs_remove_device,
2331 .set_online = lcs_new_device,
2332 .set_offline = lcs_shutdown_device,
2333};
2334
2335static ssize_t group_store(struct device_driver *ddrv, const char *buf,
2336 size_t count)
2337{
2338 int err;
2339 err = ccwgroup_create_dev(lcs_root_dev, &lcs_group_driver, 2, buf);
2340 return err ? err : count;
2341}
2342static DRIVER_ATTR_WO(group);
2343
2344static struct attribute *lcs_drv_attrs[] = {
2345 &driver_attr_group.attr,
2346 NULL,
2347};
2348static struct attribute_group lcs_drv_attr_group = {
2349 .attrs = lcs_drv_attrs,
2350};
2351static const struct attribute_group *lcs_drv_attr_groups[] = {
2352 &lcs_drv_attr_group,
2353 NULL,
2354};
2355
2356
2357
2358
2359static int
2360__init lcs_init_module(void)
2361{
2362 int rc;
2363
2364 pr_info("Loading %s\n", version);
2365 rc = lcs_register_debug_facility();
2366 LCS_DBF_TEXT(0, setup, "lcsinit");
2367 if (rc)
2368 goto out_err;
2369 lcs_root_dev = root_device_register("lcs");
2370 rc = PTR_ERR_OR_ZERO(lcs_root_dev);
2371 if (rc)
2372 goto register_err;
2373 rc = ccw_driver_register(&lcs_ccw_driver);
2374 if (rc)
2375 goto ccw_err;
2376 lcs_group_driver.driver.groups = lcs_drv_attr_groups;
2377 rc = ccwgroup_driver_register(&lcs_group_driver);
2378 if (rc)
2379 goto ccwgroup_err;
2380 return 0;
2381
2382ccwgroup_err:
2383 ccw_driver_unregister(&lcs_ccw_driver);
2384ccw_err:
2385 root_device_unregister(lcs_root_dev);
2386register_err:
2387 lcs_unregister_debug_facility();
2388out_err:
2389 pr_err("Initializing the lcs device driver failed\n");
2390 return rc;
2391}
2392
2393
2394
2395
2396
2397static void
2398__exit lcs_cleanup_module(void)
2399{
2400 pr_info("Terminating lcs module.\n");
2401 LCS_DBF_TEXT(0, trace, "cleanup");
2402 ccwgroup_driver_unregister(&lcs_group_driver);
2403 ccw_driver_unregister(&lcs_ccw_driver);
2404 root_device_unregister(lcs_root_dev);
2405 lcs_unregister_debug_facility();
2406}
2407
2408module_init(lcs_init_module);
2409module_exit(lcs_cleanup_module);
2410
2411MODULE_AUTHOR("Frank Pavlic <fpavlic@de.ibm.com>");
2412MODULE_LICENSE("GPL");
2413
2414