1 // SPDX-License-Identifier: GPL-2.0+
3 * Linux for S/390 Lan Channel Station Network Driver
5 * Copyright IBM Corp. 1999, 2009
6 * Author(s): Original Code written by
7 * DJ Barrow <djbarrow@de.ibm.com,barrow_dj@yahoo.com>
9 * Frank Pavlic <fpavlic@de.ibm.com> and
10 * Martin Schwidefsky <schwidefsky@de.ibm.com>
13 #define KMSG_COMPONENT "lcs"
14 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
16 #include <linux/module.h>
18 #include <linux/netdevice.h>
19 #include <linux/etherdevice.h>
20 #include <linux/fddidevice.h>
21 #include <linux/inetdevice.h>
23 #include <linux/igmp.h>
24 #include <linux/delay.h>
25 #include <linux/kthread.h>
26 #include <linux/slab.h>
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>
39 #if !IS_ENABLED(CONFIG_ETHERNET) && !IS_ENABLED(CONFIG_FDDI)
40 #error Cannot compile lcs.c without some net devices switched on.
44 * initialization string for output
47 static char version[] __initdata = "LCS driver";
50 * the root device for lcs group devices
52 static struct device *lcs_root_dev;
57 static void lcs_tasklet(unsigned long);
58 static void lcs_start_kernel_thread(struct work_struct *);
59 static void lcs_get_frames_cb(struct lcs_channel *, struct lcs_buffer *);
60 #ifdef CONFIG_IP_MULTICAST
61 static int lcs_send_delipm(struct lcs_card *, struct lcs_ipm_list *);
62 #endif /* CONFIG_IP_MULTICAST */
63 static int lcs_recovery(void *ptr);
66 * Debug Facility Stuff
68 static char debug_buffer[255];
69 static debug_info_t *lcs_dbf_setup;
70 static debug_info_t *lcs_dbf_trace;
73 * LCS Debug Facility functions
76 lcs_unregister_debug_facility(void)
78 debug_unregister(lcs_dbf_setup);
79 debug_unregister(lcs_dbf_trace);
83 lcs_register_debug_facility(void)
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();
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);
100 * Allocate io buffers.
103 lcs_alloc_channel(struct lcs_channel *channel)
107 LCS_DBF_TEXT(2, setup, "ichalloc");
108 for (cnt = 0; cnt < LCS_NUM_BUFFS; cnt++) {
109 /* alloc memory fo iobuffer */
110 channel->iob[cnt].data =
111 kzalloc(LCS_IOBUFFERSIZE, GFP_DMA | GFP_KERNEL);
112 if (channel->iob[cnt].data == NULL)
114 channel->iob[cnt].state = LCS_BUF_STATE_EMPTY;
116 if (cnt < LCS_NUM_BUFFS) {
117 /* Not all io buffers could be allocated. */
118 LCS_DBF_TEXT(2, setup, "echalloc");
120 kfree(channel->iob[cnt].data);
130 lcs_free_channel(struct lcs_channel *channel)
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;
145 lcs_cleanup_channel(struct lcs_channel *channel)
147 LCS_DBF_TEXT(3, setup, "cleanch");
148 /* Kill write channel tasklets. */
149 tasklet_kill(&channel->irq_tasklet);
150 /* Free channel buffers. */
151 lcs_free_channel(channel);
155 * LCS free memory for card and channels.
158 lcs_free_card(struct lcs_card *card)
160 LCS_DBF_TEXT(2, setup, "remcard");
161 LCS_DBF_HEX(2, setup, &card, sizeof(void*));
166 * LCS alloc memory for card and channels
168 static struct lcs_card *
171 struct lcs_card *card;
174 LCS_DBF_TEXT(2, setup, "alloclcs");
176 card = kzalloc(sizeof(struct lcs_card), GFP_KERNEL | GFP_DMA);
179 card->lan_type = LCS_FRAME_TYPE_AUTO;
181 card->lancmd_timeout = LCS_LANCMD_TIMEOUT_DEFAULT;
182 /* Allocate io buffers for the read channel. */
183 rc = lcs_alloc_channel(&card->read);
185 LCS_DBF_TEXT(2, setup, "iccwerr");
189 /* Allocate io buffers for the write channel. */
190 rc = lcs_alloc_channel(&card->write);
192 LCS_DBF_TEXT(2, setup, "iccwerr");
193 lcs_cleanup_channel(&card->read);
198 #ifdef CONFIG_IP_MULTICAST
199 INIT_LIST_HEAD(&card->ipm_list);
201 LCS_DBF_HEX(2, setup, &card, sizeof(void*));
206 * Setup read channel.
209 lcs_setup_read_ccws(struct lcs_card *card)
213 LCS_DBF_TEXT(2, setup, "ireadccw");
214 /* Setup read ccws. */
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;
222 * Note: we have allocated the buffer with GFP_DMA, so
223 * we do not need to do set_normalized_cda.
225 card->read.ccws[cnt].cda =
226 (__u32)virt_to_phys(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;
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 /* Last ccw is a tic (transfer in channel). */
237 card->read.ccws[LCS_NUM_BUFFS].cmd_code = LCS_CCW_TRANSFER;
238 card->read.ccws[LCS_NUM_BUFFS].cda =
239 (__u32)virt_to_phys(card->read.ccws);
240 /* Setg initial state of the read channel. */
241 card->read.state = LCS_CH_STATE_INIT;
243 card->read.io_idx = 0;
244 card->read.buf_idx = 0;
248 lcs_setup_read(struct lcs_card *card)
250 LCS_DBF_TEXT(3, setup, "initread");
252 lcs_setup_read_ccws(card);
253 /* Initialize read channel tasklet. */
254 card->read.irq_tasklet.data = (unsigned long) &card->read;
255 card->read.irq_tasklet.func = lcs_tasklet;
256 /* Initialize waitqueue. */
257 init_waitqueue_head(&card->read.wait_q);
261 * Setup write channel.
264 lcs_setup_write_ccws(struct lcs_card *card)
268 LCS_DBF_TEXT(3, setup, "iwritccw");
269 /* Setup write ccws. */
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;
277 * Note: we have allocated the buffer with GFP_DMA, so
278 * we do not need to do set_normalized_cda.
280 card->write.ccws[cnt].cda =
281 (__u32)virt_to_phys(card->write.iob[cnt].data);
283 /* Last ccw is a tic (transfer in channel). */
284 card->write.ccws[LCS_NUM_BUFFS].cmd_code = LCS_CCW_TRANSFER;
285 card->write.ccws[LCS_NUM_BUFFS].cda =
286 (__u32)virt_to_phys(card->write.ccws);
287 /* Set initial state of the write channel. */
288 card->read.state = LCS_CH_STATE_INIT;
290 card->write.io_idx = 0;
291 card->write.buf_idx = 0;
295 lcs_setup_write(struct lcs_card *card)
297 LCS_DBF_TEXT(3, setup, "initwrit");
299 lcs_setup_write_ccws(card);
300 /* Initialize write channel tasklet. */
301 card->write.irq_tasklet.data = (unsigned long) &card->write;
302 card->write.irq_tasklet.func = lcs_tasklet;
303 /* Initialize waitqueue. */
304 init_waitqueue_head(&card->write.wait_q);
308 lcs_set_allowed_threads(struct lcs_card *card, unsigned long threads)
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);
317 static int lcs_threads_running(struct lcs_card *card, unsigned long threads)
322 spin_lock_irqsave(&card->mask_lock, flags);
323 rc = (card->thread_running_mask & threads);
324 spin_unlock_irqrestore(&card->mask_lock, flags);
329 lcs_wait_for_threads(struct lcs_card *card, unsigned long threads)
331 return wait_event_interruptible(card->wait_q,
332 lcs_threads_running(card, threads) == 0);
335 static int lcs_set_thread_start_bit(struct lcs_card *card, unsigned long thread)
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);
345 card->thread_start_mask |= thread;
346 spin_unlock_irqrestore(&card->mask_lock, flags);
351 lcs_clear_thread_running_bit(struct lcs_card *card, unsigned long thread)
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);
361 static int __lcs_do_run_thread(struct lcs_card *card, unsigned long thread)
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)){
371 card->thread_start_mask &= ~thread;
372 card->thread_running_mask |= thread;
376 spin_unlock_irqrestore(&card->mask_lock, flags);
381 lcs_do_run_thread(struct lcs_card *card, unsigned long thread)
384 wait_event(card->wait_q,
385 (rc = __lcs_do_run_thread(card, thread)) >= 0);
390 lcs_do_start_thread(struct lcs_card *card, unsigned long thread)
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);
406 * Initialize channels,card and state machines.
409 lcs_setup_card(struct lcs_card *card)
411 LCS_DBF_TEXT(2, setup, "initcard");
412 LCS_DBF_HEX(2, setup, &card, sizeof(void*));
414 lcs_setup_read(card);
415 lcs_setup_write(card);
416 /* Set cards initial state. */
417 card->state = DEV_STATE_DOWN;
418 card->tx_buffer = NULL;
419 card->tx_emitted = 0;
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);
428 INIT_LIST_HEAD(&card->lancmd_waiters);
431 static void lcs_clear_multicast_list(struct lcs_card *card)
433 #ifdef CONFIG_IP_MULTICAST
434 struct lcs_ipm_list *ipm;
437 /* Free multicast list. */
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);
451 spin_unlock_irqrestore(&card->ipm_lock, flags);
456 * Cleanup channels,card and state machines.
459 lcs_cleanup_card(struct lcs_card *card)
462 LCS_DBF_TEXT(3, setup, "cleancrd");
463 LCS_DBF_HEX(2,setup,&card,sizeof(void*));
465 if (card->dev != NULL)
466 free_netdev(card->dev);
467 /* Cleanup channels. */
468 lcs_cleanup_channel(&card->write);
469 lcs_cleanup_channel(&card->read);
476 lcs_start_channel(struct lcs_channel *channel)
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);
487 channel->state = LCS_CH_STATE_RUNNING;
488 spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
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,"
500 lcs_clear_channel(struct lcs_channel *channel)
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);
511 LCS_DBF_TEXT_(4, trace, "ecsc%s",
512 dev_name(&channel->ccwdev->dev));
515 wait_event(channel->wait_q, (channel->state == LCS_CH_STATE_CLEARED));
516 channel->state = LCS_CH_STATE_STOPPED;
525 lcs_stop_channel(struct lcs_channel *channel)
530 if (channel->state == LCS_CH_STATE_STOPPED)
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);
539 LCS_DBF_TEXT_(4, trace, "ehsc%s",
540 dev_name(&channel->ccwdev->dev));
543 /* Asynchronous halt initialted. Wait for its completion. */
544 wait_event(channel->wait_q, (channel->state == LCS_CH_STATE_HALTED));
545 lcs_clear_channel(channel);
550 * start read and write channel
553 lcs_start_channels(struct lcs_card *card)
557 LCS_DBF_TEXT(2, trace, "chstart");
558 /* start read channel */
559 rc = lcs_start_channel(&card->read);
562 /* start write channel */
563 rc = lcs_start_channel(&card->write);
565 lcs_stop_channel(&card->read);
570 * stop read and write channel
573 lcs_stop_channels(struct lcs_card *card)
575 LCS_DBF_TEXT(2, trace, "chhalt");
576 lcs_stop_channel(&card->read);
577 lcs_stop_channel(&card->write);
584 static struct lcs_buffer *
585 __lcs_get_buffer(struct lcs_channel *channel)
589 LCS_DBF_TEXT(5, trace, "_getbuff");
590 index = channel->io_idx;
592 if (channel->iob[index].state == LCS_BUF_STATE_EMPTY) {
593 channel->iob[index].state = LCS_BUF_STATE_LOCKED;
594 return channel->iob + index;
596 index = (index + 1) & (LCS_NUM_BUFFS - 1);
597 } while (index != channel->io_idx);
601 static struct lcs_buffer *
602 lcs_get_buffer(struct lcs_channel *channel)
604 struct lcs_buffer *buffer;
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);
615 * Resume channel program if the channel is suspended.
618 __lcs_resume_channel(struct lcs_channel *channel)
622 if (channel->state != LCS_CH_STATE_SUSPENDED)
624 if (channel->ccws[channel->io_idx].flags & CCW_FLAG_SUSPEND)
626 LCS_DBF_TEXT_(5, trace, "rsch%s", dev_name(&channel->ccwdev->dev));
627 rc = ccw_device_resume(channel->ccwdev);
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"
635 channel->state = LCS_CH_STATE_RUNNING;
641 * Make a buffer ready for processing.
643 static void __lcs_ready_buffer_bits(struct lcs_channel *channel, int index)
647 LCS_DBF_TEXT(5, trace, "rdybits");
648 prev = (index - 1) & (LCS_NUM_BUFFS - 1);
649 next = (index + 1) & (LCS_NUM_BUFFS - 1);
650 /* Check if we may clear the suspend bit of this buffer. */
651 if (channel->ccws[next].flags & CCW_FLAG_SUSPEND) {
652 /* Check if we have to set the PCI bit. */
653 if (!(channel->ccws[prev].flags & CCW_FLAG_SUSPEND))
654 /* Suspend bit of the previous buffer is not set. */
655 channel->ccws[index].flags |= CCW_FLAG_PCI;
656 /* Suspend bit of the next buffer is set. */
657 channel->ccws[index].flags &= ~CCW_FLAG_SUSPEND;
662 lcs_ready_buffer(struct lcs_channel *channel, struct lcs_buffer *buffer)
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;
674 channel->ccws[index].count = buffer->count;
675 /* Check relevant PCI/suspend bits. */
676 __lcs_ready_buffer_bits(channel, index);
677 rc = __lcs_resume_channel(channel);
678 spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
683 * Mark the buffer as processed. Take care of the suspend bit
684 * of the previous buffer. This function is called from
685 * interrupt context, so the lock must not be taken.
688 __lcs_processed_buffer(struct lcs_channel *channel, struct lcs_buffer *buffer)
690 int index, prev, next;
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 /* Set the suspend bit and clear the PCI bit of this buffer. */
699 channel->ccws[index].flags |= CCW_FLAG_SUSPEND;
700 channel->ccws[index].flags &= ~CCW_FLAG_PCI;
701 /* Check the suspend bit of the previous buffer. */
702 if (channel->iob[prev].state == LCS_BUF_STATE_READY) {
704 * Previous buffer is in state ready. It might have
705 * happened in lcs_ready_buffer that the suspend bit
706 * has not been cleared to avoid an endless loop.
709 __lcs_ready_buffer_bits(channel, prev);
711 /* Clear PCI bit of next buffer. */
712 channel->ccws[next].flags &= ~CCW_FLAG_PCI;
713 return __lcs_resume_channel(channel);
717 * Put a processed buffer back to state empty.
720 lcs_release_buffer(struct lcs_channel *channel, struct lcs_buffer *buffer)
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);
733 * Get buffer for a lan command.
735 static struct lcs_buffer *
736 lcs_get_lancmd(struct lcs_card *card, int count)
738 struct lcs_buffer *buffer;
741 LCS_DBF_TEXT(4, trace, "getlncmd");
742 /* Get buffer and wait if none is available. */
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;
751 cmd->type = LCS_FRAME_TYPE_CONTROL;
758 lcs_get_reply(struct lcs_reply *reply)
760 refcount_inc(&reply->refcnt);
764 lcs_put_reply(struct lcs_reply *reply)
766 if (refcount_dec_and_test(&reply->refcnt))
770 static struct lcs_reply *
771 lcs_alloc_reply(struct lcs_cmd *cmd)
773 struct lcs_reply *reply;
775 LCS_DBF_TEXT(4, trace, "getreply");
777 reply = kzalloc(sizeof(struct lcs_reply), GFP_ATOMIC);
780 refcount_set(&reply->refcnt, 1);
781 reply->sequence_no = cmd->sequence_no;
784 init_waitqueue_head(&reply->wait_q);
790 * Notifier function for lancmd replies. Called from read irq.
793 lcs_notify_lancmd_waiters(struct lcs_card *card, struct lcs_cmd *cmd)
795 struct list_head *l, *n;
796 struct lcs_reply *reply;
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);
808 reply->rc = cmd->return_code;
809 wake_up(&reply->wait_q);
810 lcs_put_reply(reply);
814 spin_unlock(&card->lock);
818 * Emit buffer of a lan command.
821 lcs_lancmd_timeout(struct timer_list *t)
823 struct lcs_reply *reply = from_timer(reply, t, timer);
824 struct lcs_reply *list_reply, *r;
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);
837 wake_up(&reply->wait_q);
838 lcs_put_reply(reply);
842 spin_unlock_irqrestore(&reply->card->lock, flags);
846 lcs_send_lancmd(struct lcs_card *card, struct lcs_buffer *buffer,
847 void (*reply_callback)(struct lcs_card *, struct lcs_cmd *))
849 struct lcs_reply *reply;
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);
861 reply->callback = reply_callback;
863 spin_lock_irqsave(&card->lock, flags);
864 list_add_tail(&reply->list, &card->lancmd_waiters);
865 spin_unlock_irqrestore(&card->lock, flags);
867 buffer->callback = lcs_release_buffer;
868 rc = lcs_ready_buffer(&card->write, buffer);
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);
877 lcs_put_reply(reply);
878 return rc ? -EIO : 0;
882 * LCS startup command
885 lcs_send_startup(struct lcs_card *card, __u8 initiator)
887 struct lcs_buffer *buffer;
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);
900 * LCS shutdown command
903 lcs_send_shutdown(struct lcs_card *card)
905 struct lcs_buffer *buffer;
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);
917 * LCS lanstat command
920 __lcs_lanstat_cb(struct lcs_card *card, struct lcs_cmd *cmd)
922 LCS_DBF_TEXT(2, trace, "statcb");
923 memcpy(card->mac, cmd->cmd.lcs_lanstat_cmd.mac_addr, LCS_MAC_LENGTH);
927 lcs_send_lanstat(struct lcs_card *card)
929 struct lcs_buffer *buffer;
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 /* Setup lanstat command. */
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);
944 * send stoplan command
947 lcs_send_stoplan(struct lcs_card *card, __u8 initiator)
949 struct lcs_buffer *buffer;
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);
963 * send startlan command
966 __lcs_send_startlan_cb(struct lcs_card *card, struct lcs_cmd *cmd)
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;
974 lcs_send_startlan(struct lcs_card *card, __u8 initiator)
976 struct lcs_buffer *buffer;
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);
989 #ifdef CONFIG_IP_MULTICAST
991 * send setipm command (Multicast)
994 lcs_send_setipm(struct lcs_card *card,struct lcs_ipm_list *ipm_list)
996 struct lcs_buffer *buffer;
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);
1015 * send delipm command (Multicast)
1018 lcs_send_delipm(struct lcs_card *card,struct lcs_ipm_list *ipm_list)
1020 struct lcs_buffer *buffer;
1021 struct lcs_cmd *cmd;
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);
1039 * check if multicast is supported by LCS
1042 __lcs_check_multicast_cb(struct lcs_card *card, struct lcs_cmd *cmd)
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;
1052 lcs_check_multicast_support(struct lcs_card *card)
1054 struct lcs_buffer *buffer;
1055 struct lcs_cmd *cmd;
1058 LCS_DBF_TEXT(2, trace, "cmdqipa");
1059 /* Send query ipassist. */
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);
1070 pr_err("Query IPAssist failed. Assuming unsupported!\n");
1073 if (card->ip_assists_supported & LCS_IPASS_MULTICAST_SUPPORT)
1079 * set or del multicast address on LCS card
1082 lcs_fix_multicast_list(struct lcs_card *card)
1084 struct list_head failed_list;
1085 struct lcs_ipm_list *ipm, *tmp;
1086 unsigned long flags;
1089 LCS_DBF_TEXT(4,trace, "fixipm");
1090 INIT_LIST_HEAD(&failed_list);
1091 spin_lock_irqsave(&card->ipm_lock, flags);
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 /* del from ipm_list so no one else can tamper with
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);
1103 pr_info("Adding multicast address failed."
1104 " Table possibly full!\n");
1105 /* store ipm in failed list -> will be added
1106 * to ipm_list again, so a retry will be done
1107 * during the next call of this function */
1108 list_add_tail(&ipm->list, &failed_list);
1110 ipm->ipm_state = LCS_IPM_STATE_ON_CARD;
1111 /* re-insert into ipm_list */
1112 list_add_tail(&ipm->list, &card->ipm_list);
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);
1122 case LCS_IPM_STATE_ON_CARD:
1126 /* re-insert all entries from the failed_list into ipm_list */
1127 list_for_each_entry_safe(ipm, tmp, &failed_list, list)
1128 list_move_tail(&ipm->list, &card->ipm_list);
1130 spin_unlock_irqrestore(&card->ipm_lock, flags);
1134 * get mac address for the relevant Multicast address
1137 lcs_get_mac_for_ipm(__be32 ipm, char *mac, struct net_device *dev)
1139 LCS_DBF_TEXT(4,trace, "getmac");
1140 ip_eth_mc_map(ipm, mac);
1144 * function called by net device to handle multicast address relevant things
1146 static void lcs_remove_mc_addresses(struct lcs_card *card,
1147 struct in_device *in4_dev)
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];
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) )
1168 ipm->ipm_state = LCS_IPM_STATE_DEL_REQUIRED;
1170 spin_unlock_irqrestore(&card->ipm_lock, flags);
1173 static struct lcs_ipm_list *lcs_check_addr_entry(struct lcs_card *card,
1174 struct ip_mc_list *im4,
1177 struct lcs_ipm_list *tmp, *ipm = NULL;
1178 struct list_head *l;
1179 unsigned long flags;
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) ) {
1192 spin_unlock_irqrestore(&card->ipm_lock, flags);
1196 static void lcs_set_mc_addresses(struct lcs_card *card,
1197 struct in_device *in4_dev)
1200 struct ip_mc_list *im4;
1201 struct lcs_ipm_list *ipm;
1202 char buf[MAX_ADDR_LEN];
1203 unsigned long flags;
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);
1211 continue; /* Address already in list. */
1212 ipm = kzalloc(sizeof(struct lcs_ipm_list), GFP_ATOMIC);
1214 pr_info("Not enough memory to add"
1215 " new multicast entry!\n");
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);
1229 lcs_register_mc_addresses(void *data)
1231 struct lcs_card *card;
1232 struct in_device *in4_dev;
1234 card = (struct lcs_card *) data;
1236 if (!lcs_do_run_thread(card, LCS_SET_MC_THREAD))
1238 LCS_DBF_TEXT(4, trace, "regmulti");
1240 in4_dev = in_dev_get(card->dev);
1241 if (in4_dev == NULL)
1244 lcs_remove_mc_addresses(card,in4_dev);
1245 lcs_set_mc_addresses(card, in4_dev);
1247 in_dev_put(in4_dev);
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);
1259 lcs_clear_thread_running_bit(card, LCS_SET_MC_THREAD);
1262 #endif /* CONFIG_IP_MULTICAST */
1265 * function called by net device to
1266 * handle multicast address relevant things
1269 lcs_set_multicast_list(struct net_device *dev)
1271 #ifdef CONFIG_IP_MULTICAST
1272 struct lcs_card *card;
1274 LCS_DBF_TEXT(4, trace, "setmulti");
1275 card = (struct lcs_card *) dev->ml_priv;
1277 if (!lcs_set_thread_start_bit(card, LCS_SET_MC_THREAD))
1278 schedule_work(&card->kernel_thread_starter);
1279 #endif /* CONFIG_IP_MULTICAST */
1283 lcs_check_irb_error(struct ccw_device *cdev, struct irb *irb)
1288 switch (PTR_ERR(irb)) {
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);
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);
1302 dev_warn(&cdev->dev,
1303 "An error occurred on the LCS device, rc=%ld\n",
1305 LCS_DBF_TEXT(2, trace, "ckirberr");
1306 LCS_DBF_TEXT(2, trace, " rc???");
1308 return PTR_ERR(irb);
1312 lcs_get_problem(struct ccw_device *cdev, struct irb *irb)
1317 sense = (char *) irb->ecw;
1318 cstat = irb->scsw.cmd.cstat;
1319 dstat = irb->scsw.cmd.dstat;
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");
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");
1333 if (sense[LCS_SENSE_BYTE_0] &
1334 LCS_SENSE_CMD_REJECT) {
1335 LCS_DBF_TEXT(2, trace, "CMDREJ");
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");
1345 LCS_DBF_TEXT(2, trace, "DGENCHK");
1352 lcs_schedule_recovery(struct lcs_card *card)
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);
1360 * IRQ Handler for LCS channels
1363 lcs_irq(struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
1365 struct lcs_card *card;
1366 struct lcs_channel *channel;
1370 if (lcs_check_irb_error(cdev, irb))
1373 card = CARD_FROM_DEV(cdev);
1374 if (card->read.ccwdev == cdev)
1375 channel = &card->read;
1377 channel = &card->write;
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);
1387 /* Check for channel and device errors presented */
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",
1395 channel->state = LCS_CH_STATE_ERROR;
1398 if (channel->state == LCS_CH_STATE_ERROR) {
1399 lcs_schedule_recovery(card);
1400 wake_up(&card->wait_q);
1403 /* How far in the ccw chain have we processed? */
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)
1409 if ((irb->scsw.cmd.actl & SCSW_ACTL_SUSPENDED) ||
1410 (irb->scsw.cmd.cstat & SCHN_STAT_PCI))
1411 /* Bloody io subsystem tells us lies about cpa... */
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);
1417 (channel->io_idx + 1) & (LCS_NUM_BUFFS - 1);
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 /* Mark channel as stopped. */
1425 channel->state = LCS_CH_STATE_STOPPED;
1426 else if (irb->scsw.cmd.actl & SCSW_ACTL_SUSPENDED)
1427 /* CCW execution stopped on a suspend bit. */
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);
1434 /* The channel has been stopped by halt_IO. */
1435 channel->state = LCS_CH_STATE_HALTED;
1437 if (irb->scsw.cmd.fctl & SCSW_FCTL_CLEAR_FUNC)
1438 channel->state = LCS_CH_STATE_CLEARED;
1439 /* Do the rest in the tasklet. */
1440 tasklet_schedule(&channel->irq_tasklet);
1444 * Tasklet for IRQ handler
1447 lcs_tasklet(unsigned long data)
1449 unsigned long flags;
1450 struct lcs_channel *channel;
1451 struct lcs_buffer *iob;
1454 channel = (struct lcs_channel *) data;
1455 LCS_DBF_TEXT_(5, trace, "tlet%s", dev_name(&channel->ccwdev->dev));
1457 /* Check for processed buffers. */
1459 buf_idx = channel->buf_idx;
1460 while (iob[buf_idx].state == LCS_BUF_STATE_PROCESSED) {
1461 /* Do the callback thing. */
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);
1466 channel->buf_idx = buf_idx;
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);
1476 /* Something happened on the channel. Wake up waiters. */
1477 wake_up(&channel->wait_q);
1481 * Finish current tx buffer and make it ready for transmit.
1484 __lcs_emit_txbuffer(struct lcs_card *card)
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;
1495 * Callback for finished tx buffers.
1498 lcs_txbuffer_cb(struct lcs_channel *channel, struct lcs_buffer *buffer)
1500 struct lcs_card *card;
1502 LCS_DBF_TEXT(5, trace, "txbuffcb");
1503 /* Put buffer back to pool. */
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);
1510 if (card->tx_emitted <= 0 && card->tx_buffer != NULL)
1512 * Last running tx buffer has finished. Submit partially
1513 * filled current buffer.
1515 __lcs_emit_txbuffer(card);
1516 spin_unlock(&card->lock);
1520 * Packet transmit function called by network stack
1522 static netdev_tx_t __lcs_start_xmit(struct lcs_card *card, struct sk_buff *skb,
1523 struct net_device *dev)
1525 struct lcs_header *header;
1526 int rc = NETDEV_TX_OK;
1528 LCS_DBF_TEXT(5, trace, "hardxmit");
1530 card->stats.tx_dropped++;
1531 card->stats.tx_errors++;
1532 return NETDEV_TX_OK;
1534 if (card->state != DEV_STATE_UP) {
1536 card->stats.tx_dropped++;
1537 card->stats.tx_errors++;
1538 card->stats.tx_carrier_errors++;
1539 return NETDEV_TX_OK;
1541 if (skb->protocol == htons(ETH_P_IPV6)) {
1543 return NETDEV_TX_OK;
1545 netif_stop_queue(card->dev);
1546 spin_lock(&card->lock);
1547 if (card->tx_buffer != NULL &&
1548 card->tx_buffer->count + sizeof(struct lcs_header) +
1549 skb->len + sizeof(u16) > LCS_IOBUFFERSIZE)
1550 /* skb too big for current tx buffer. */
1551 __lcs_emit_txbuffer(card);
1552 if (card->tx_buffer == NULL) {
1553 /* Get new tx buffer */
1554 card->tx_buffer = lcs_get_buffer(&card->write);
1555 if (card->tx_buffer == NULL) {
1556 card->stats.tx_dropped++;
1557 rc = NETDEV_TX_BUSY;
1560 card->tx_buffer->callback = lcs_txbuffer_cb;
1561 card->tx_buffer->count = 0;
1563 header = (struct lcs_header *)
1564 (card->tx_buffer->data + card->tx_buffer->count);
1565 card->tx_buffer->count += skb->len + sizeof(struct lcs_header);
1566 header->offset = card->tx_buffer->count;
1567 header->type = card->lan_type;
1568 header->slot = card->portno;
1569 skb_copy_from_linear_data(skb, header + 1, skb->len);
1570 spin_unlock(&card->lock);
1571 card->stats.tx_bytes += skb->len;
1572 card->stats.tx_packets++;
1574 netif_wake_queue(card->dev);
1575 spin_lock(&card->lock);
1576 if (card->tx_emitted <= 0 && card->tx_buffer != NULL)
1577 /* If this is the first tx buffer emit it immediately. */
1578 __lcs_emit_txbuffer(card);
1580 spin_unlock(&card->lock);
1584 static netdev_tx_t lcs_start_xmit(struct sk_buff *skb, struct net_device *dev)
1586 struct lcs_card *card;
1589 LCS_DBF_TEXT(5, trace, "pktxmit");
1590 card = (struct lcs_card *) dev->ml_priv;
1591 rc = __lcs_start_xmit(card, skb, dev);
1596 * send startlan and lanstat command to make LCS device ready
1599 lcs_startlan_auto(struct lcs_card *card)
1603 LCS_DBF_TEXT(2, trace, "strtauto");
1604 #if IS_ENABLED(CONFIG_ETHERNET)
1605 card->lan_type = LCS_FRAME_TYPE_ENET;
1606 rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP);
1611 #if IS_ENABLED(CONFIG_FDDI)
1612 card->lan_type = LCS_FRAME_TYPE_FDDI;
1613 rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP);
1621 lcs_startlan(struct lcs_card *card)
1625 LCS_DBF_TEXT(2, trace, "startlan");
1627 if (card->portno != LCS_INVALID_PORT_NO) {
1628 if (card->lan_type == LCS_FRAME_TYPE_AUTO)
1629 rc = lcs_startlan_auto(card);
1631 rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP);
1633 for (i = 0; i <= 16; i++) {
1635 if (card->lan_type != LCS_FRAME_TYPE_AUTO)
1636 rc = lcs_send_startlan(card,
1637 LCS_INITIATOR_TCPIP);
1639 /* autodetecting lan type */
1640 rc = lcs_startlan_auto(card);
1646 return lcs_send_lanstat(card);
1651 * LCS detect function
1652 * setup channels and make them I/O ready
1655 lcs_detect(struct lcs_card *card)
1659 LCS_DBF_TEXT(2, setup, "lcsdetct");
1660 /* start/reset card */
1662 netif_stop_queue(card->dev);
1663 rc = lcs_stop_channels(card);
1665 rc = lcs_start_channels(card);
1667 rc = lcs_send_startup(card, LCS_INITIATOR_TCPIP);
1669 rc = lcs_startlan(card);
1673 card->state = DEV_STATE_UP;
1675 card->state = DEV_STATE_DOWN;
1676 card->write.state = LCS_CH_STATE_INIT;
1677 card->read.state = LCS_CH_STATE_INIT;
1686 lcs_stopcard(struct lcs_card *card)
1690 LCS_DBF_TEXT(3, setup, "stopcard");
1692 if (card->read.state != LCS_CH_STATE_STOPPED &&
1693 card->write.state != LCS_CH_STATE_STOPPED &&
1694 card->read.state != LCS_CH_STATE_ERROR &&
1695 card->write.state != LCS_CH_STATE_ERROR &&
1696 card->state == DEV_STATE_UP) {
1697 lcs_clear_multicast_list(card);
1698 rc = lcs_send_stoplan(card,LCS_INITIATOR_TCPIP);
1699 rc = lcs_send_shutdown(card);
1701 rc = lcs_stop_channels(card);
1702 card->state = DEV_STATE_DOWN;
1708 * Kernel Thread helper functions for LGW initiated commands
1711 lcs_start_kernel_thread(struct work_struct *work)
1713 struct lcs_card *card = container_of(work, struct lcs_card, kernel_thread_starter);
1714 LCS_DBF_TEXT(5, trace, "krnthrd");
1715 if (lcs_do_start_thread(card, LCS_RECOVERY_THREAD))
1716 kthread_run(lcs_recovery, card, "lcs_recover");
1717 #ifdef CONFIG_IP_MULTICAST
1718 if (lcs_do_start_thread(card, LCS_SET_MC_THREAD))
1719 kthread_run(lcs_register_mc_addresses, card, "regipm");
1724 * Process control frames.
1727 lcs_get_control(struct lcs_card *card, struct lcs_cmd *cmd)
1729 LCS_DBF_TEXT(5, trace, "getctrl");
1730 if (cmd->initiator == LCS_INITIATOR_LGW) {
1731 switch(cmd->cmd_code) {
1732 case LCS_CMD_STARTUP:
1733 case LCS_CMD_STARTLAN:
1734 lcs_schedule_recovery(card);
1736 case LCS_CMD_STOPLAN:
1738 pr_warn("Stoplan for %s initiated by LGW\n",
1740 netif_carrier_off(card->dev);
1744 LCS_DBF_TEXT(5, trace, "noLGWcmd");
1748 lcs_notify_lancmd_waiters(card, cmd);
1752 * Unpack network packet.
1755 lcs_get_skb(struct lcs_card *card, char *skb_data, unsigned int skb_len)
1757 struct sk_buff *skb;
1759 LCS_DBF_TEXT(5, trace, "getskb");
1760 if (card->dev == NULL ||
1761 card->state != DEV_STATE_UP)
1762 /* The card isn't up. Ignore the packet. */
1765 skb = dev_alloc_skb(skb_len);
1767 dev_err(&card->dev->dev,
1768 " Allocating a socket buffer to interface %s failed\n",
1770 card->stats.rx_dropped++;
1773 skb_put_data(skb, skb_data, skb_len);
1774 skb->protocol = card->lan_type_trans(skb, card->dev);
1775 card->stats.rx_bytes += skb_len;
1776 card->stats.rx_packets++;
1777 if (skb->protocol == htons(ETH_P_802_2))
1778 *((__u32 *)skb->cb) = ++card->pkt_seq;
1783 * LCS main routine to get packets and lancmd replies from the buffers
1786 lcs_get_frames_cb(struct lcs_channel *channel, struct lcs_buffer *buffer)
1788 struct lcs_card *card;
1789 struct lcs_header *lcs_hdr;
1792 LCS_DBF_TEXT(5, trace, "lcsgtpkt");
1793 lcs_hdr = (struct lcs_header *) buffer->data;
1794 if (lcs_hdr->offset == LCS_ILLEGAL_OFFSET) {
1795 LCS_DBF_TEXT(4, trace, "-eiogpkt");
1798 card = container_of(channel, struct lcs_card, read);
1800 while (lcs_hdr->offset != 0) {
1801 if (lcs_hdr->offset <= 0 ||
1802 lcs_hdr->offset > LCS_IOBUFFERSIZE ||
1803 lcs_hdr->offset < offset) {
1804 /* Offset invalid. */
1805 card->stats.rx_length_errors++;
1806 card->stats.rx_errors++;
1809 /* What kind of frame is it? */
1810 if (lcs_hdr->type == LCS_FRAME_TYPE_CONTROL) {
1811 /* Control frame. */
1812 lcs_get_control(card, (struct lcs_cmd *) lcs_hdr);
1813 } else if (lcs_hdr->type == LCS_FRAME_TYPE_ENET ||
1814 lcs_hdr->type == LCS_FRAME_TYPE_TR ||
1815 lcs_hdr->type == LCS_FRAME_TYPE_FDDI) {
1816 /* Normal network packet. */
1817 lcs_get_skb(card, (char *)(lcs_hdr + 1),
1818 lcs_hdr->offset - offset -
1819 sizeof(struct lcs_header));
1821 /* Unknown frame type. */
1822 ; // FIXME: error message ?
1824 /* Proceed to next frame. */
1825 offset = lcs_hdr->offset;
1826 lcs_hdr->offset = LCS_ILLEGAL_OFFSET;
1827 lcs_hdr = (struct lcs_header *) (buffer->data + offset);
1829 /* The buffer is now empty. Make it ready again. */
1830 lcs_ready_buffer(&card->read, buffer);
1834 * get network statistics for ifconfig and other user programs
1836 static struct net_device_stats *
1837 lcs_getstats(struct net_device *dev)
1839 struct lcs_card *card;
1841 LCS_DBF_TEXT(4, trace, "netstats");
1842 card = (struct lcs_card *) dev->ml_priv;
1843 return &card->stats;
1848 * This function will be called by user doing ifconfig xxx down
1851 lcs_stop_device(struct net_device *dev)
1853 struct lcs_card *card;
1856 LCS_DBF_TEXT(2, trace, "stopdev");
1857 card = (struct lcs_card *) dev->ml_priv;
1858 netif_carrier_off(dev);
1859 netif_tx_disable(dev);
1860 dev->flags &= ~IFF_UP;
1861 wait_event(card->write.wait_q,
1862 (card->write.state != LCS_CH_STATE_RUNNING));
1863 rc = lcs_stopcard(card);
1865 dev_err(&card->dev->dev,
1866 " Shutting down the LCS device failed\n");
1871 * start lcs device and make it runnable
1872 * This function will be called by user doing ifconfig xxx up
1875 lcs_open_device(struct net_device *dev)
1877 struct lcs_card *card;
1880 LCS_DBF_TEXT(2, trace, "opendev");
1881 card = (struct lcs_card *) dev->ml_priv;
1882 /* initialize statistics */
1883 rc = lcs_detect(card);
1885 pr_err("Error in opening device!\n");
1888 dev->flags |= IFF_UP;
1889 netif_carrier_on(dev);
1890 netif_wake_queue(dev);
1891 card->state = DEV_STATE_UP;
1897 * show function for portno called by cat or similar things
1900 lcs_portno_show (struct device *dev, struct device_attribute *attr, char *buf)
1902 struct lcs_card *card;
1904 card = dev_get_drvdata(dev);
1909 return sprintf(buf, "%d\n", card->portno);
1913 * store the value which is piped to file portno
1916 lcs_portno_store (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1918 struct lcs_card *card;
1922 card = dev_get_drvdata(dev);
1927 rc = kstrtos16(buf, 0, &value);
1930 /* TODO: sanity checks */
1931 card->portno = value;
1933 card->dev->dev_port = card->portno;
1939 static DEVICE_ATTR(portno, 0644, lcs_portno_show, lcs_portno_store);
1941 static const char *lcs_type[] = {
1946 "unknown channel type",
1947 "unsupported channel type",
1951 lcs_type_show(struct device *dev, struct device_attribute *attr, char *buf)
1953 struct ccwgroup_device *cgdev;
1955 cgdev = to_ccwgroupdev(dev);
1959 return sprintf(buf, "%s\n", lcs_type[cgdev->cdev[0]->id.driver_info]);
1962 static DEVICE_ATTR(type, 0444, lcs_type_show, NULL);
1965 lcs_timeout_show(struct device *dev, struct device_attribute *attr, char *buf)
1967 struct lcs_card *card;
1969 card = dev_get_drvdata(dev);
1971 return card ? sprintf(buf, "%u\n", card->lancmd_timeout) : 0;
1975 lcs_timeout_store (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1977 struct lcs_card *card;
1981 card = dev_get_drvdata(dev);
1986 rc = kstrtouint(buf, 0, &value);
1989 /* TODO: sanity checks */
1990 card->lancmd_timeout = value;
1996 static DEVICE_ATTR(lancmd_timeout, 0644, lcs_timeout_show, lcs_timeout_store);
1999 lcs_dev_recover_store(struct device *dev, struct device_attribute *attr,
2000 const char *buf, size_t count)
2002 struct lcs_card *card = dev_get_drvdata(dev);
2008 if (card->state != DEV_STATE_UP)
2010 i = simple_strtoul(buf, &tmp, 16);
2012 lcs_schedule_recovery(card);
2016 static DEVICE_ATTR(recover, 0200, NULL, lcs_dev_recover_store);
2018 static struct attribute * lcs_attrs[] = {
2019 &dev_attr_portno.attr,
2020 &dev_attr_type.attr,
2021 &dev_attr_lancmd_timeout.attr,
2022 &dev_attr_recover.attr,
2025 static struct attribute_group lcs_attr_group = {
2028 static const struct attribute_group *lcs_attr_groups[] = {
2032 static const struct device_type lcs_devtype = {
2034 .groups = lcs_attr_groups,
2038 * lcs_probe_device is called on establishing a new ccwgroup_device.
2041 lcs_probe_device(struct ccwgroup_device *ccwgdev)
2043 struct lcs_card *card;
2045 if (!get_device(&ccwgdev->dev))
2048 LCS_DBF_TEXT(2, setup, "add_dev");
2049 card = lcs_alloc_card();
2051 LCS_DBF_TEXT_(2, setup, " rc%d", -ENOMEM);
2052 put_device(&ccwgdev->dev);
2055 dev_set_drvdata(&ccwgdev->dev, card);
2056 ccwgdev->cdev[0]->handler = lcs_irq;
2057 ccwgdev->cdev[1]->handler = lcs_irq;
2058 card->gdev = ccwgdev;
2059 INIT_WORK(&card->kernel_thread_starter, lcs_start_kernel_thread);
2060 card->thread_start_mask = 0;
2061 card->thread_allowed_mask = 0;
2062 card->thread_running_mask = 0;
2063 ccwgdev->dev.type = &lcs_devtype;
2069 lcs_register_netdev(struct ccwgroup_device *ccwgdev)
2071 struct lcs_card *card;
2073 LCS_DBF_TEXT(2, setup, "regnetdv");
2074 card = dev_get_drvdata(&ccwgdev->dev);
2075 if (card->dev->reg_state != NETREG_UNINITIALIZED)
2077 SET_NETDEV_DEV(card->dev, &ccwgdev->dev);
2078 return register_netdev(card->dev);
2082 * lcs_new_device will be called by setting the group device online.
2084 static const struct net_device_ops lcs_netdev_ops = {
2085 .ndo_open = lcs_open_device,
2086 .ndo_stop = lcs_stop_device,
2087 .ndo_get_stats = lcs_getstats,
2088 .ndo_start_xmit = lcs_start_xmit,
2091 static const struct net_device_ops lcs_mc_netdev_ops = {
2092 .ndo_open = lcs_open_device,
2093 .ndo_stop = lcs_stop_device,
2094 .ndo_get_stats = lcs_getstats,
2095 .ndo_start_xmit = lcs_start_xmit,
2096 .ndo_set_rx_mode = lcs_set_multicast_list,
2100 lcs_new_device(struct ccwgroup_device *ccwgdev)
2102 struct lcs_card *card;
2103 struct net_device *dev=NULL;
2104 enum lcs_dev_states recover_state;
2107 card = dev_get_drvdata(&ccwgdev->dev);
2111 LCS_DBF_TEXT(2, setup, "newdev");
2112 LCS_DBF_HEX(3, setup, &card, sizeof(void*));
2113 card->read.ccwdev = ccwgdev->cdev[0];
2114 card->write.ccwdev = ccwgdev->cdev[1];
2116 recover_state = card->state;
2117 rc = ccw_device_set_online(card->read.ccwdev);
2120 rc = ccw_device_set_online(card->write.ccwdev);
2124 LCS_DBF_TEXT(3, setup, "lcsnewdv");
2126 lcs_setup_card(card);
2127 rc = lcs_detect(card);
2129 LCS_DBF_TEXT(2, setup, "dtctfail");
2130 dev_err(&ccwgdev->dev,
2131 "Detecting a network adapter for LCS devices"
2132 " failed with rc=%d (0x%x)\n", rc, rc);
2137 LCS_DBF_TEXT(2, setup, "samedev");
2138 LCS_DBF_HEX(3, setup, &card, sizeof(void*));
2141 switch (card->lan_type) {
2142 #if IS_ENABLED(CONFIG_ETHERNET)
2143 case LCS_FRAME_TYPE_ENET:
2144 card->lan_type_trans = eth_type_trans;
2145 dev = alloc_etherdev(0);
2148 #if IS_ENABLED(CONFIG_FDDI)
2149 case LCS_FRAME_TYPE_FDDI:
2150 card->lan_type_trans = fddi_type_trans;
2151 dev = alloc_fddidev(0);
2155 LCS_DBF_TEXT(3, setup, "errinit");
2156 pr_err(" Initialization failed\n");
2162 card->dev->ml_priv = card;
2163 card->dev->netdev_ops = &lcs_netdev_ops;
2164 card->dev->dev_port = card->portno;
2165 eth_hw_addr_set(card->dev, card->mac);
2166 #ifdef CONFIG_IP_MULTICAST
2167 if (!lcs_check_multicast_support(card))
2168 card->dev->netdev_ops = &lcs_mc_netdev_ops;
2171 lcs_set_allowed_threads(card,0xffffffff);
2172 if (recover_state == DEV_STATE_RECOVER) {
2173 lcs_set_multicast_list(card->dev);
2174 card->dev->flags |= IFF_UP;
2175 netif_carrier_on(card->dev);
2176 netif_wake_queue(card->dev);
2177 card->state = DEV_STATE_UP;
2182 if (lcs_register_netdev(ccwgdev) != 0)
2185 /* Print out supported assists: IPv6 */
2186 pr_info("LCS device %s %s IPv6 support\n", card->dev->name,
2187 (card->ip_assists_supported & LCS_IPASS_IPV6_SUPPORT) ?
2188 "with" : "without");
2189 /* Print out supported assist: Multicast */
2190 pr_info("LCS device %s %s Multicast support\n", card->dev->name,
2191 (card->ip_assists_supported & LCS_IPASS_MULTICAST_SUPPORT) ?
2192 "with" : "without");
2196 ccw_device_set_offline(card->write.ccwdev);
2198 ccw_device_set_offline(card->read.ccwdev);
2204 * lcs_shutdown_device, called when setting the group device offline.
2207 __lcs_shutdown_device(struct ccwgroup_device *ccwgdev, int recovery_mode)
2209 struct lcs_card *card;
2210 enum lcs_dev_states recover_state;
2211 int ret = 0, ret2 = 0, ret3 = 0;
2213 LCS_DBF_TEXT(3, setup, "shtdndev");
2214 card = dev_get_drvdata(&ccwgdev->dev);
2217 if (recovery_mode == 0) {
2218 lcs_set_allowed_threads(card, 0);
2219 if (lcs_wait_for_threads(card, LCS_SET_MC_THREAD))
2220 return -ERESTARTSYS;
2222 LCS_DBF_HEX(3, setup, &card, sizeof(void*));
2223 recover_state = card->state;
2225 ret = lcs_stop_device(card->dev);
2226 ret2 = ccw_device_set_offline(card->read.ccwdev);
2227 ret3 = ccw_device_set_offline(card->write.ccwdev);
2229 ret = (ret2) ? ret2 : ret3;
2231 LCS_DBF_TEXT_(3, setup, "1err:%d", ret);
2232 if (recover_state == DEV_STATE_UP) {
2233 card->state = DEV_STATE_RECOVER;
2239 lcs_shutdown_device(struct ccwgroup_device *ccwgdev)
2241 return __lcs_shutdown_device(ccwgdev, 0);
2245 * drive lcs recovery after startup and startlan initiated by Lan Gateway
2248 lcs_recovery(void *ptr)
2250 struct lcs_card *card;
2251 struct ccwgroup_device *gdev;
2254 card = (struct lcs_card *) ptr;
2256 LCS_DBF_TEXT(4, trace, "recover1");
2257 if (!lcs_do_run_thread(card, LCS_RECOVERY_THREAD))
2259 LCS_DBF_TEXT(4, trace, "recover2");
2261 dev_warn(&gdev->dev,
2262 "A recovery process has been started for the LCS device\n");
2263 rc = __lcs_shutdown_device(gdev, 1);
2264 rc = lcs_new_device(gdev);
2266 pr_info("Device %s successfully recovered!\n",
2269 pr_info("Device %s could not be recovered!\n",
2271 lcs_clear_thread_running_bit(card, LCS_RECOVERY_THREAD);
2276 * lcs_remove_device, free buffers and card
2279 lcs_remove_device(struct ccwgroup_device *ccwgdev)
2281 struct lcs_card *card;
2283 card = dev_get_drvdata(&ccwgdev->dev);
2287 LCS_DBF_TEXT(3, setup, "remdev");
2288 LCS_DBF_HEX(3, setup, &card, sizeof(void*));
2289 if (ccwgdev->state == CCWGROUP_ONLINE) {
2290 lcs_shutdown_device(ccwgdev);
2293 unregister_netdev(card->dev);
2294 lcs_cleanup_card(card);
2295 lcs_free_card(card);
2296 dev_set_drvdata(&ccwgdev->dev, NULL);
2297 put_device(&ccwgdev->dev);
2300 static struct ccw_device_id lcs_ids[] = {
2301 {CCW_DEVICE(0x3088, 0x08), .driver_info = lcs_channel_type_parallel},
2302 {CCW_DEVICE(0x3088, 0x1f), .driver_info = lcs_channel_type_2216},
2303 {CCW_DEVICE(0x3088, 0x60), .driver_info = lcs_channel_type_osa2},
2306 MODULE_DEVICE_TABLE(ccw, lcs_ids);
2308 static struct ccw_driver lcs_ccw_driver = {
2310 .owner = THIS_MODULE,
2314 .probe = ccwgroup_probe_ccwdev,
2315 .remove = ccwgroup_remove_ccwdev,
2316 .int_class = IRQIO_LCS,
2320 * LCS ccwgroup driver registration
2322 static struct ccwgroup_driver lcs_group_driver = {
2324 .owner = THIS_MODULE,
2327 .ccw_driver = &lcs_ccw_driver,
2328 .setup = lcs_probe_device,
2329 .remove = lcs_remove_device,
2330 .set_online = lcs_new_device,
2331 .set_offline = lcs_shutdown_device,
2334 static ssize_t group_store(struct device_driver *ddrv, const char *buf,
2338 err = ccwgroup_create_dev(lcs_root_dev, &lcs_group_driver, 2, buf);
2339 return err ? err : count;
2341 static DRIVER_ATTR_WO(group);
2343 static struct attribute *lcs_drv_attrs[] = {
2344 &driver_attr_group.attr,
2347 static struct attribute_group lcs_drv_attr_group = {
2348 .attrs = lcs_drv_attrs,
2350 static const struct attribute_group *lcs_drv_attr_groups[] = {
2351 &lcs_drv_attr_group,
2356 * LCS Module/Kernel initialization function
2359 __init lcs_init_module(void)
2363 pr_info("Loading %s\n", version);
2364 rc = lcs_register_debug_facility();
2365 LCS_DBF_TEXT(0, setup, "lcsinit");
2368 lcs_root_dev = root_device_register("lcs");
2369 rc = PTR_ERR_OR_ZERO(lcs_root_dev);
2372 rc = ccw_driver_register(&lcs_ccw_driver);
2375 lcs_group_driver.driver.groups = lcs_drv_attr_groups;
2376 rc = ccwgroup_driver_register(&lcs_group_driver);
2382 ccw_driver_unregister(&lcs_ccw_driver);
2384 root_device_unregister(lcs_root_dev);
2386 lcs_unregister_debug_facility();
2388 pr_err("Initializing the lcs device driver failed\n");
2394 * LCS module cleanup function
2397 __exit lcs_cleanup_module(void)
2399 pr_info("Terminating lcs module.\n");
2400 LCS_DBF_TEXT(0, trace, "cleanup");
2401 ccwgroup_driver_unregister(&lcs_group_driver);
2402 ccw_driver_unregister(&lcs_ccw_driver);
2403 root_device_unregister(lcs_root_dev);
2404 lcs_unregister_debug_facility();
2407 module_init(lcs_init_module);
2408 module_exit(lcs_cleanup_module);
2410 MODULE_AUTHOR("Frank Pavlic <fpavlic@de.ibm.com>");
2411 MODULE_LICENSE("GPL");