2 * linux/drivers/s390/net/lcs.c
4 * Linux for S/390 Lan Channel Station Network Driver
6 * Copyright (C) 1999-2001 IBM Deutschland Entwicklung GmbH,
8 * Author(s): Original Code written by
9 * DJ Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
11 * Frank Pavlic (pavlic@de.ibm.com) and
12 * Martin Schwidefsky <schwidefsky@de.ibm.com>
14 * $Revision: 1.85 $ $Date: 2004/08/04 11:05:43 $
16 * This program is free software; you can redistribute it and/or modify
17 * it under the terms of the GNU General Public License as published by
18 * the Free Software Foundation; either version 2, or (at your option)
21 * This program is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 * GNU General Public License for more details.
26 * You should have received a copy of the GNU General Public License
27 * along with this program; if not, write to the Free Software
28 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
31 #include <linux/module.h>
33 #include <linux/netdevice.h>
34 #include <linux/etherdevice.h>
35 #include <linux/trdevice.h>
36 #include <linux/fddidevice.h>
37 #include <linux/inetdevice.h>
39 #include <linux/igmp.h>
40 #include <linux/delay.h>
44 #include <asm/debug.h>
45 #include <asm/idals.h>
46 #include <asm/timex.h>
47 #include <linux/device.h>
48 #include <asm/ccwgroup.h>
54 #if !defined(CONFIG_NET_ETHERNET) && \
55 !defined(CONFIG_TR) && !defined(CONFIG_FDDI)
56 #error Cannot compile lcs.c without some net devices switched on.
60 * initialization string for output
62 #define VERSION_LCS_C "$Revision: 1.85 $"
64 static char version[] __initdata = "LCS driver ("VERSION_LCS_C "/" VERSION_LCS_H ")";
65 static char debug_buffer[255];
70 static void lcs_tasklet(unsigned long);
71 static void lcs_start_kernel_thread(struct lcs_card *card);
72 static void lcs_get_frames_cb(struct lcs_channel *, struct lcs_buffer *);
75 * Debug Facility Stuff
77 static debug_info_t *lcs_dbf_setup;
78 static debug_info_t *lcs_dbf_trace;
81 * LCS Debug Facility functions
84 lcs_unregister_debug_facility(void)
87 debug_unregister(lcs_dbf_setup);
89 debug_unregister(lcs_dbf_trace);
93 lcs_register_debug_facility(void)
95 lcs_dbf_setup = debug_register("lcs_setup", 1, 1, 8);
96 lcs_dbf_trace = debug_register("lcs_trace", 1, 2, 8);
97 if (lcs_dbf_setup == NULL || lcs_dbf_trace == NULL) {
98 PRINT_ERR("Not enough memory for debug facility.\n");
99 lcs_unregister_debug_facility();
102 debug_register_view(lcs_dbf_setup, &debug_hex_ascii_view);
103 debug_set_level(lcs_dbf_setup, 2);
104 debug_register_view(lcs_dbf_trace, &debug_hex_ascii_view);
105 debug_set_level(lcs_dbf_trace, 2);
110 * Allocate io buffers.
113 lcs_alloc_channel(struct lcs_channel *channel)
117 LCS_DBF_TEXT(2, setup, "ichalloc");
118 for (cnt = 0; cnt < LCS_NUM_BUFFS; cnt++) {
119 /* alloc memory fo iobuffer */
120 channel->iob[cnt].data = (void *)
121 kmalloc(LCS_IOBUFFERSIZE, GFP_DMA | GFP_KERNEL);
122 if (channel->iob[cnt].data == NULL)
124 memset(channel->iob[cnt].data, 0, LCS_IOBUFFERSIZE);
125 channel->iob[cnt].state = BUF_STATE_EMPTY;
127 if (cnt < LCS_NUM_BUFFS) {
128 /* Not all io buffers could be allocated. */
129 LCS_DBF_TEXT(2, setup, "echalloc");
131 kfree(channel->iob[cnt].data);
141 lcs_free_channel(struct lcs_channel *channel)
145 LCS_DBF_TEXT(2, setup, "ichfree");
146 for (cnt = 0; cnt < LCS_NUM_BUFFS; cnt++) {
147 if (channel->iob[cnt].data != NULL)
148 kfree(channel->iob[cnt].data);
149 channel->iob[cnt].data = NULL;
157 lcs_cleanup_channel(struct lcs_channel *channel)
159 LCS_DBF_TEXT(3, setup, "cleanch");
160 /* Kill write channel tasklets. */
161 tasklet_kill(&channel->irq_tasklet);
162 /* Free channel buffers. */
163 lcs_free_channel(channel);
167 * LCS free memory for card and channels.
170 lcs_free_card(struct lcs_card *card)
172 LCS_DBF_TEXT(2, setup, "remcard");
173 LCS_DBF_HEX(2, setup, &card, sizeof(void*));
178 * LCS alloc memory for card and channels
180 static struct lcs_card *
183 struct lcs_card *card;
186 LCS_DBF_TEXT(2, setup, "alloclcs");
188 card = kmalloc(sizeof(struct lcs_card), GFP_KERNEL | GFP_DMA);
191 memset(card, 0, sizeof(struct lcs_card));
192 card->lan_type = LCS_FRAME_TYPE_AUTO;
193 card->lancmd_timeout = LCS_LANCMD_TIMEOUT_DEFAULT;
194 /* Allocate io buffers for the read channel. */
195 rc = lcs_alloc_channel(&card->read);
197 LCS_DBF_TEXT(2, setup, "iccwerr");
201 /* Allocate io buffers for the write channel. */
202 rc = lcs_alloc_channel(&card->write);
204 LCS_DBF_TEXT(2, setup, "iccwerr");
205 lcs_cleanup_channel(&card->read);
210 #ifdef CONFIG_IP_MULTICAST
211 INIT_LIST_HEAD(&card->ipm_list);
213 LCS_DBF_HEX(2, setup, &card, sizeof(void*));
218 * Setup read channel.
221 lcs_setup_read_ccws(struct lcs_card *card)
225 LCS_DBF_TEXT(2, setup, "ireadccw");
226 /* Setup read ccws. */
227 memset(card->read.ccws, 0, sizeof (struct ccw1) * (LCS_NUM_BUFFS + 1));
228 for (cnt = 0; cnt < LCS_NUM_BUFFS; cnt++) {
229 card->read.ccws[cnt].cmd_code = LCS_CCW_READ;
230 card->read.ccws[cnt].count = LCS_IOBUFFERSIZE;
231 card->read.ccws[cnt].flags =
232 CCW_FLAG_CC | CCW_FLAG_SLI | CCW_FLAG_PCI;
234 * Note: we have allocated the buffer with GFP_DMA, so
235 * we do not need to do set_normalized_cda.
237 card->read.ccws[cnt].cda =
238 (__u32) __pa(card->read.iob[cnt].data);
239 ((struct lcs_header *)
240 card->read.iob[cnt].data)->offset = LCS_ILLEGAL_OFFSET;
241 card->read.iob[cnt].callback = lcs_get_frames_cb;
242 card->read.iob[cnt].state = BUF_STATE_READY;
243 card->read.iob[cnt].count = LCS_IOBUFFERSIZE;
245 card->read.ccws[0].flags &= ~CCW_FLAG_PCI;
246 card->read.ccws[LCS_NUM_BUFFS - 1].flags &= ~CCW_FLAG_PCI;
247 card->read.ccws[LCS_NUM_BUFFS - 1].flags |= CCW_FLAG_SUSPEND;
248 /* Last ccw is a tic (transfer in channel). */
249 card->read.ccws[LCS_NUM_BUFFS].cmd_code = LCS_CCW_TRANSFER;
250 card->read.ccws[LCS_NUM_BUFFS].cda =
251 (__u32) __pa(card->read.ccws);
252 /* Setg initial state of the read channel. */
253 card->read.state = CH_STATE_INIT;
255 card->read.io_idx = 0;
256 card->read.buf_idx = 0;
260 lcs_setup_read(struct lcs_card *card)
262 LCS_DBF_TEXT(3, setup, "initread");
264 lcs_setup_read_ccws(card);
265 /* Initialize read channel tasklet. */
266 card->read.irq_tasklet.data = (unsigned long) &card->read;
267 card->read.irq_tasklet.func = lcs_tasklet;
268 /* Initialize waitqueue. */
269 init_waitqueue_head(&card->read.wait_q);
273 * Setup write channel.
276 lcs_setup_write_ccws(struct lcs_card *card)
280 LCS_DBF_TEXT(3, setup, "iwritccw");
281 /* Setup write ccws. */
282 memset(card->write.ccws, 0, sizeof(struct ccw1) * LCS_NUM_BUFFS + 1);
283 for (cnt = 0; cnt < LCS_NUM_BUFFS; cnt++) {
284 card->write.ccws[cnt].cmd_code = LCS_CCW_WRITE;
285 card->write.ccws[cnt].count = 0;
286 card->write.ccws[cnt].flags =
287 CCW_FLAG_SUSPEND | CCW_FLAG_CC | CCW_FLAG_SLI;
289 * Note: we have allocated the buffer with GFP_DMA, so
290 * we do not need to do set_normalized_cda.
292 card->write.ccws[cnt].cda =
293 (__u32) __pa(card->write.iob[cnt].data);
295 /* Last ccw is a tic (transfer in channel). */
296 card->write.ccws[LCS_NUM_BUFFS].cmd_code = LCS_CCW_TRANSFER;
297 card->write.ccws[LCS_NUM_BUFFS].cda =
298 (__u32) __pa(card->write.ccws);
299 /* Set initial state of the write channel. */
300 card->read.state = CH_STATE_INIT;
302 card->write.io_idx = 0;
303 card->write.buf_idx = 0;
307 lcs_setup_write(struct lcs_card *card)
309 LCS_DBF_TEXT(3, setup, "initwrit");
311 lcs_setup_write_ccws(card);
312 /* Initialize write channel tasklet. */
313 card->write.irq_tasklet.data = (unsigned long) &card->write;
314 card->write.irq_tasklet.func = lcs_tasklet;
315 /* Initialize waitqueue. */
316 init_waitqueue_head(&card->write.wait_q);
322 * Initialize channels,card and state machines.
325 lcs_setup_card(struct lcs_card *card)
327 LCS_DBF_TEXT(2, setup, "initcard");
328 LCS_DBF_HEX(2, setup, &card, sizeof(void*));
330 lcs_setup_read(card);
331 lcs_setup_write(card);
332 /* Set cards initial state. */
333 card->state = DEV_STATE_DOWN;
334 card->tx_buffer = NULL;
335 card->tx_emitted = 0;
337 /* Initialize kernel thread task used for LGW commands. */
338 INIT_WORK(&card->kernel_thread_starter,
339 (void *)lcs_start_kernel_thread,card);
340 card->thread_mask = 0;
341 spin_lock_init(&card->lock);
342 spin_lock_init(&card->ipm_lock);
343 #ifdef CONFIG_IP_MULTICAST
344 INIT_LIST_HEAD(&card->ipm_list);
346 INIT_LIST_HEAD(&card->lancmd_waiters);
350 * Cleanup channels,card and state machines.
353 lcs_cleanup_card(struct lcs_card *card)
355 struct list_head *l, *n;
356 struct lcs_ipm_list *ipm_list;
358 LCS_DBF_TEXT(3, setup, "cleancrd");
359 LCS_DBF_HEX(2,setup,&card,sizeof(void*));
360 #ifdef CONFIG_IP_MULTICAST
361 /* Free multicast list. */
362 list_for_each_safe(l, n, &card->ipm_list) {
363 ipm_list = list_entry(l, struct lcs_ipm_list, list);
364 list_del(&ipm_list->list);
368 if (card->dev != NULL)
369 free_netdev(card->dev);
370 /* Cleanup channels. */
371 lcs_cleanup_channel(&card->write);
372 lcs_cleanup_channel(&card->read);
379 lcs_start_channel(struct lcs_channel *channel)
384 LCS_DBF_TEXT_(4,trace,"ssch%s", channel->ccwdev->dev.bus_id);
385 spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
386 rc = ccw_device_start(channel->ccwdev,
387 channel->ccws + channel->io_idx, 0, 0,
388 DOIO_DENY_PREFETCH | DOIO_ALLOW_SUSPEND);
390 channel->state = CH_STATE_RUNNING;
391 spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
393 LCS_DBF_TEXT_(4,trace,"essh%s", channel->ccwdev->dev.bus_id);
394 PRINT_ERR("Error in starting channel, rc=%d!\n", rc);
400 lcs_clear_channel(struct lcs_channel *channel)
405 LCS_DBF_TEXT(4,trace,"clearch");
406 LCS_DBF_TEXT_(4,trace,"%s", channel->ccwdev->dev.bus_id);
407 spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
408 rc = ccw_device_clear(channel->ccwdev, (addr_t) channel);
409 spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
411 LCS_DBF_TEXT_(4,trace,"ecsc%s", channel->ccwdev->dev.bus_id);
414 wait_event(channel->wait_q, (channel->state == CH_STATE_CLEARED));
415 channel->state = CH_STATE_STOPPED;
424 lcs_stop_channel(struct lcs_channel *channel)
429 if (channel->state == CH_STATE_STOPPED)
431 LCS_DBF_TEXT(4,trace,"haltsch");
432 LCS_DBF_TEXT_(4,trace,"%s", channel->ccwdev->dev.bus_id);
433 spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
434 rc = ccw_device_halt(channel->ccwdev, (addr_t) channel);
435 spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
437 LCS_DBF_TEXT_(4,trace,"ehsc%s", channel->ccwdev->dev.bus_id);
440 /* Asynchronous halt initialted. Wait for its completion. */
441 wait_event(channel->wait_q, (channel->state == CH_STATE_HALTED));
442 lcs_clear_channel(channel);
447 * start read and write channel
450 lcs_start_channels(struct lcs_card *card)
454 LCS_DBF_TEXT(2, trace, "chstart");
455 /* start read channel */
456 rc = lcs_start_channel(&card->read);
459 /* start write channel */
460 rc = lcs_start_channel(&card->write);
462 lcs_stop_channel(&card->read);
467 * stop read and write channel
470 lcs_stop_channels(struct lcs_card *card)
472 LCS_DBF_TEXT(2, trace, "chhalt");
473 lcs_stop_channel(&card->read);
474 lcs_stop_channel(&card->write);
481 static struct lcs_buffer *
482 __lcs_get_buffer(struct lcs_channel *channel)
486 LCS_DBF_TEXT(5, trace, "_getbuff");
487 index = channel->io_idx;
489 if (channel->iob[index].state == BUF_STATE_EMPTY) {
490 channel->iob[index].state = BUF_STATE_LOCKED;
491 return channel->iob + index;
493 index = (index + 1) & (LCS_NUM_BUFFS - 1);
494 } while (index != channel->io_idx);
498 static struct lcs_buffer *
499 lcs_get_buffer(struct lcs_channel *channel)
501 struct lcs_buffer *buffer;
504 LCS_DBF_TEXT(5, trace, "getbuff");
505 spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
506 buffer = __lcs_get_buffer(channel);
507 spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
512 * Resume channel program if the channel is suspended.
515 __lcs_resume_channel(struct lcs_channel *channel)
519 if (channel->state != CH_STATE_SUSPENDED)
521 if (channel->ccws[channel->io_idx].flags & CCW_FLAG_SUSPEND)
523 LCS_DBF_TEXT_(5, trace, "rsch%s", channel->ccwdev->dev.bus_id);
524 rc = ccw_device_resume(channel->ccwdev);
526 LCS_DBF_TEXT_(4, trace, "ersc%s", channel->ccwdev->dev.bus_id);
527 PRINT_ERR("Error in lcs_resume_channel: rc=%d\n",rc);
529 channel->state = CH_STATE_RUNNING;
535 * Make a buffer ready for processing.
538 __lcs_ready_buffer_bits(struct lcs_channel *channel, int index)
542 LCS_DBF_TEXT(5, trace, "rdybits");
543 prev = (index - 1) & (LCS_NUM_BUFFS - 1);
544 next = (index + 1) & (LCS_NUM_BUFFS - 1);
545 /* Check if we may clear the suspend bit of this buffer. */
546 if (channel->ccws[next].flags & CCW_FLAG_SUSPEND) {
547 /* Check if we have to set the PCI bit. */
548 if (!(channel->ccws[prev].flags & CCW_FLAG_SUSPEND))
549 /* Suspend bit of the previous buffer is not set. */
550 channel->ccws[index].flags |= CCW_FLAG_PCI;
551 /* Suspend bit of the next buffer is set. */
552 channel->ccws[index].flags &= ~CCW_FLAG_SUSPEND;
557 lcs_ready_buffer(struct lcs_channel *channel, struct lcs_buffer *buffer)
562 LCS_DBF_TEXT(5, trace, "rdybuff");
563 if (buffer->state != BUF_STATE_LOCKED &&
564 buffer->state != BUF_STATE_PROCESSED)
566 spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
567 buffer->state = BUF_STATE_READY;
568 index = buffer - channel->iob;
570 channel->ccws[index].count = buffer->count;
571 /* Check relevant PCI/suspend bits. */
572 __lcs_ready_buffer_bits(channel, index);
573 rc = __lcs_resume_channel(channel);
574 spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
579 * Mark the buffer as processed. Take care of the suspend bit
580 * of the previous buffer. This function is called from
581 * interrupt context, so the lock must not be taken.
584 __lcs_processed_buffer(struct lcs_channel *channel, struct lcs_buffer *buffer)
586 int index, prev, next;
588 LCS_DBF_TEXT(5, trace, "prcsbuff");
589 if (buffer->state != BUF_STATE_READY)
591 buffer->state = BUF_STATE_PROCESSED;
592 index = buffer - channel->iob;
593 prev = (index - 1) & (LCS_NUM_BUFFS - 1);
594 next = (index + 1) & (LCS_NUM_BUFFS - 1);
595 /* Set the suspend bit and clear the PCI bit of this buffer. */
596 channel->ccws[index].flags |= CCW_FLAG_SUSPEND;
597 channel->ccws[index].flags &= ~CCW_FLAG_PCI;
598 /* Check the suspend bit of the previous buffer. */
599 if (channel->iob[prev].state == BUF_STATE_READY) {
601 * Previous buffer is in state ready. It might have
602 * happened in lcs_ready_buffer that the suspend bit
603 * has not been cleared to avoid an endless loop.
606 __lcs_ready_buffer_bits(channel, prev);
608 /* Clear PCI bit of next buffer. */
609 channel->ccws[next].flags &= ~CCW_FLAG_PCI;
610 return __lcs_resume_channel(channel);
614 * Put a processed buffer back to state empty.
617 lcs_release_buffer(struct lcs_channel *channel, struct lcs_buffer *buffer)
621 LCS_DBF_TEXT(5, trace, "relbuff");
622 if (buffer->state != BUF_STATE_LOCKED &&
623 buffer->state != BUF_STATE_PROCESSED)
625 spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
626 buffer->state = BUF_STATE_EMPTY;
627 spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
631 * Get buffer for a lan command.
633 static struct lcs_buffer *
634 lcs_get_lancmd(struct lcs_card *card, int count)
636 struct lcs_buffer *buffer;
639 LCS_DBF_TEXT(4, trace, "getlncmd");
640 /* Get buffer and wait if none is available. */
641 wait_event(card->write.wait_q,
642 ((buffer = lcs_get_buffer(&card->write)) != NULL));
643 count += sizeof(struct lcs_header);
644 *(__u16 *)(buffer->data + count) = 0;
645 buffer->count = count + sizeof(__u16);
646 buffer->callback = lcs_release_buffer;
647 cmd = (struct lcs_cmd *) buffer->data;
649 cmd->type = LCS_FRAME_TYPE_CONTROL;
655 * Notifier function for lancmd replies. Called from read irq.
658 lcs_notify_lancmd_waiters(struct lcs_card *card, struct lcs_cmd *cmd)
660 struct list_head *l, *n;
661 struct lcs_reply *reply;
663 LCS_DBF_TEXT(4, trace, "notiwait");
664 spin_lock(&card->lock);
665 list_for_each_safe(l, n, &card->lancmd_waiters) {
666 reply = list_entry(l, struct lcs_reply, list);
667 if (reply->sequence_no == cmd->sequence_no) {
668 list_del(&reply->list);
669 if (reply->callback != NULL)
670 reply->callback(card, cmd);
672 reply->rc = cmd->return_code;
673 wake_up(&reply->wait_q);
677 spin_unlock(&card->lock);
681 * Emit buffer of a lan comand.
684 lcs_lancmd_timeout(unsigned long data)
686 struct lcs_reply *reply;
688 LCS_DBF_TEXT(4, trace, "timeout");
689 reply = (struct lcs_reply *) data;
690 list_del(&reply->list);
693 wake_up(&reply->wait_q);
697 lcs_send_lancmd(struct lcs_card *card, struct lcs_buffer *buffer,
698 void (*reply_callback)(struct lcs_card *, struct lcs_cmd *))
700 struct lcs_reply reply;
702 struct timer_list timer;
705 LCS_DBF_TEXT(4, trace, "sendcmd");
706 cmd = (struct lcs_cmd *) buffer->data;
707 cmd->sequence_no = ++card->sequence_no;
708 cmd->return_code = 0;
709 reply.sequence_no = cmd->sequence_no;
710 reply.callback = reply_callback;
713 init_waitqueue_head(&reply.wait_q);
714 spin_lock(&card->lock);
715 list_add_tail(&reply.list, &card->lancmd_waiters);
716 spin_unlock(&card->lock);
717 buffer->callback = lcs_release_buffer;
718 rc = lcs_ready_buffer(&card->write, buffer);
722 timer.function = lcs_lancmd_timeout;
723 timer.data = (unsigned long) &reply;
724 timer.expires = jiffies + HZ*card->lancmd_timeout;
726 wait_event(reply.wait_q, reply.received);
728 LCS_DBF_TEXT_(4, trace, "rc:%d",reply.rc);
729 return reply.rc ? -EIO : 0;
733 * LCS startup command
736 lcs_send_startup(struct lcs_card *card, __u8 initiator)
738 struct lcs_buffer *buffer;
741 LCS_DBF_TEXT(2, trace, "startup");
742 buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
743 cmd = (struct lcs_cmd *) buffer->data;
744 cmd->cmd_code = LCS_CMD_STARTUP;
745 cmd->initiator = initiator;
746 cmd->cmd.lcs_startup.buff_size = LCS_IOBUFFERSIZE;
747 return lcs_send_lancmd(card, buffer, NULL);
751 * LCS shutdown command
754 lcs_send_shutdown(struct lcs_card *card)
756 struct lcs_buffer *buffer;
759 LCS_DBF_TEXT(2, trace, "shutdown");
760 buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
761 cmd = (struct lcs_cmd *) buffer->data;
762 cmd->cmd_code = LCS_CMD_SHUTDOWN;
763 cmd->initiator = LCS_INITIATOR_TCPIP;
764 return lcs_send_lancmd(card, buffer, NULL);
768 * LCS lanstat command
771 __lcs_lanstat_cb(struct lcs_card *card, struct lcs_cmd *cmd)
773 LCS_DBF_TEXT(2, trace, "statcb");
774 memcpy(card->mac, cmd->cmd.lcs_lanstat_cmd.mac_addr, LCS_MAC_LENGTH);
778 lcs_send_lanstat(struct lcs_card *card)
780 struct lcs_buffer *buffer;
783 LCS_DBF_TEXT(2,trace, "cmdstat");
784 buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
785 cmd = (struct lcs_cmd *) buffer->data;
786 /* Setup lanstat command. */
787 cmd->cmd_code = LCS_CMD_LANSTAT;
788 cmd->initiator = LCS_INITIATOR_TCPIP;
789 cmd->cmd.lcs_std_cmd.lan_type = card->lan_type;
790 cmd->cmd.lcs_std_cmd.portno = card->portno;
791 return lcs_send_lancmd(card, buffer, __lcs_lanstat_cb);
795 * send stoplan command
798 lcs_send_stoplan(struct lcs_card *card, __u8 initiator)
800 struct lcs_buffer *buffer;
803 LCS_DBF_TEXT(2, trace, "cmdstpln");
804 buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
805 cmd = (struct lcs_cmd *) buffer->data;
806 cmd->cmd_code = LCS_CMD_STOPLAN;
807 cmd->initiator = initiator;
808 cmd->cmd.lcs_std_cmd.lan_type = card->lan_type;
809 cmd->cmd.lcs_std_cmd.portno = card->portno;
810 return lcs_send_lancmd(card, buffer, NULL);
814 * send startlan command
817 __lcs_send_startlan_cb(struct lcs_card *card, struct lcs_cmd *cmd)
819 LCS_DBF_TEXT(2, trace, "srtlancb");
820 card->lan_type = cmd->cmd.lcs_std_cmd.lan_type;
821 card->portno = cmd->cmd.lcs_std_cmd.portno;
825 lcs_send_startlan(struct lcs_card *card, __u8 initiator)
827 struct lcs_buffer *buffer;
830 LCS_DBF_TEXT(2, trace, "cmdstaln");
831 buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
832 cmd = (struct lcs_cmd *) buffer->data;
833 cmd->cmd_code = LCS_CMD_STARTLAN;
834 cmd->initiator = initiator;
835 cmd->cmd.lcs_std_cmd.lan_type = card->lan_type;
836 cmd->cmd.lcs_std_cmd.portno = card->portno;
837 return lcs_send_lancmd(card, buffer, __lcs_send_startlan_cb);
840 #ifdef CONFIG_IP_MULTICAST
842 * send setipm command (Multicast)
845 lcs_send_setipm(struct lcs_card *card,struct lcs_ipm_list *ipm_list)
847 struct lcs_buffer *buffer;
850 LCS_DBF_TEXT(2, trace, "cmdsetim");
851 buffer = lcs_get_lancmd(card, LCS_MULTICAST_CMD_SIZE);
852 cmd = (struct lcs_cmd *) buffer->data;
853 cmd->cmd_code = LCS_CMD_SETIPM;
854 cmd->initiator = LCS_INITIATOR_TCPIP;
855 cmd->cmd.lcs_qipassist.lan_type = card->lan_type;
856 cmd->cmd.lcs_qipassist.portno = card->portno;
857 cmd->cmd.lcs_qipassist.version = 4;
858 cmd->cmd.lcs_qipassist.num_ip_pairs = 1;
859 memcpy(cmd->cmd.lcs_qipassist.lcs_ipass_ctlmsg.ip_mac_pair,
860 &ipm_list->ipm, sizeof (struct lcs_ip_mac_pair));
861 LCS_DBF_TEXT_(2, trace, "%x",ipm_list->ipm.ip_addr);
862 return lcs_send_lancmd(card, buffer, NULL);
866 * send delipm command (Multicast)
869 lcs_send_delipm(struct lcs_card *card,struct lcs_ipm_list *ipm_list)
871 struct lcs_buffer *buffer;
874 LCS_DBF_TEXT(2, trace, "cmddelim");
875 buffer = lcs_get_lancmd(card, LCS_MULTICAST_CMD_SIZE);
876 cmd = (struct lcs_cmd *) buffer->data;
877 cmd->cmd_code = LCS_CMD_DELIPM;
878 cmd->initiator = LCS_INITIATOR_TCPIP;
879 cmd->cmd.lcs_qipassist.lan_type = card->lan_type;
880 cmd->cmd.lcs_qipassist.portno = card->portno;
881 cmd->cmd.lcs_qipassist.version = 4;
882 cmd->cmd.lcs_qipassist.num_ip_pairs = 1;
883 memcpy(cmd->cmd.lcs_qipassist.lcs_ipass_ctlmsg.ip_mac_pair,
884 &ipm_list->ipm, sizeof (struct lcs_ip_mac_pair));
885 LCS_DBF_TEXT_(2, trace, "%x",ipm_list->ipm.ip_addr);
886 return lcs_send_lancmd(card, buffer, NULL);
890 * check if multicast is supported by LCS
893 __lcs_check_multicast_cb(struct lcs_card *card, struct lcs_cmd *cmd)
895 LCS_DBF_TEXT(2, trace, "chkmccb");
896 card->ip_assists_supported =
897 cmd->cmd.lcs_qipassist.ip_assists_supported;
898 card->ip_assists_enabled =
899 cmd->cmd.lcs_qipassist.ip_assists_enabled;
903 lcs_check_multicast_support(struct lcs_card *card)
905 struct lcs_buffer *buffer;
909 LCS_DBF_TEXT(2, trace, "cmdqipa");
910 /* Send query ipassist. */
911 buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
912 cmd = (struct lcs_cmd *) buffer->data;
913 cmd->cmd_code = LCS_CMD_QIPASSIST;
914 cmd->initiator = LCS_INITIATOR_TCPIP;
915 cmd->cmd.lcs_qipassist.lan_type = card->lan_type;
916 cmd->cmd.lcs_qipassist.portno = card->portno;
917 cmd->cmd.lcs_qipassist.version = 4;
918 cmd->cmd.lcs_qipassist.num_ip_pairs = 1;
919 rc = lcs_send_lancmd(card, buffer, __lcs_check_multicast_cb);
921 PRINT_ERR("Query IPAssist failed. Assuming unsupported!\n");
924 /* Print out supported assists: IPv6 */
925 PRINT_INFO("LCS device %s %s IPv6 support\n", card->dev->name,
926 (card->ip_assists_supported & LCS_IPASS_IPV6_SUPPORT) ?
928 /* Print out supported assist: Multicast */
929 PRINT_INFO("LCS device %s %s Multicast support\n", card->dev->name,
930 (card->ip_assists_supported & LCS_IPASS_MULTICAST_SUPPORT) ?
932 if (card->ip_assists_supported & LCS_IPASS_MULTICAST_SUPPORT)
938 * set or del multicast address on LCS card
941 lcs_fix_multicast_list(struct lcs_card *card)
943 struct list_head *l, *n;
944 struct lcs_ipm_list *ipm;
946 LCS_DBF_TEXT(4,trace, "fixipm");
947 spin_lock(&card->ipm_lock);
948 list_for_each_safe(l, n, &card->ipm_list) {
949 ipm = list_entry(l, struct lcs_ipm_list, list);
950 switch (ipm->ipm_state) {
951 case LCS_IPM_STATE_SET_REQUIRED:
952 if (lcs_send_setipm(card, ipm))
953 PRINT_INFO("Adding multicast address failed."
954 "Table possibly full!\n");
956 ipm->ipm_state = LCS_IPM_STATE_ON_CARD;
958 case LCS_IPM_STATE_DEL_REQUIRED:
959 lcs_send_delipm(card, ipm);
960 list_del(&ipm->list);
963 case LCS_IPM_STATE_ON_CARD:
967 if (card->state == DEV_STATE_UP)
968 netif_wake_queue(card->dev);
969 spin_unlock(&card->ipm_lock);
973 * get mac address for the relevant Multicast address
976 lcs_get_mac_for_ipm(__u32 ipm, char *mac, struct net_device *dev)
978 LCS_DBF_TEXT(4,trace, "getmac");
979 if (dev->type == ARPHRD_IEEE802_TR)
980 ip_tr_mc_map(ipm, mac);
982 ip_eth_mc_map(ipm, mac);
986 * function called by net device to handle multicast address relevant things
989 lcs_register_mc_addresses(void *data)
991 struct lcs_card *card;
992 char buf[MAX_ADDR_LEN];
994 struct ip_mc_list *im4;
995 struct in_device *in4_dev;
996 struct lcs_ipm_list *ipm, *tmp;
999 LCS_DBF_TEXT(4, trace, "regmulti");
1001 card = (struct lcs_card *) data;
1002 in4_dev = in_dev_get(card->dev);
1003 if (in4_dev == NULL)
1005 read_lock(&in4_dev->lock);
1006 spin_lock(&card->ipm_lock);
1007 /* Check for multicast addresses to be removed. */
1008 list_for_each(l, &card->ipm_list) {
1009 ipm = list_entry(l, struct lcs_ipm_list, list);
1010 for (im4 = in4_dev->mc_list; im4 != NULL; im4 = im4->next) {
1011 lcs_get_mac_for_ipm(im4->multiaddr, buf, card->dev);
1012 if (memcmp(buf, &ipm->ipm.mac_addr,
1013 LCS_MAC_LENGTH) == 0 &&
1014 ipm->ipm.ip_addr == im4->multiaddr)
1018 ipm->ipm_state = LCS_IPM_STATE_DEL_REQUIRED;
1020 /* Check for multicast addresses to be added. */
1021 for (im4 = in4_dev->mc_list; im4; im4 = im4->next) {
1022 lcs_get_mac_for_ipm(im4->multiaddr, buf, card->dev);
1024 list_for_each(l, &card->ipm_list) {
1025 tmp = list_entry(l, struct lcs_ipm_list, list);
1026 if (memcmp(buf, &tmp->ipm.mac_addr,
1027 LCS_MAC_LENGTH) == 0 &&
1028 tmp->ipm.ip_addr == im4->multiaddr) {
1034 continue; /* Address already in list. */
1035 ipm = (struct lcs_ipm_list *)
1036 kmalloc(sizeof(struct lcs_ipm_list), GFP_ATOMIC);
1038 PRINT_INFO("Not enough memory to add "
1039 "new multicast entry!\n");
1042 memset(ipm, 0, sizeof(struct lcs_ipm_list));
1043 memcpy(&ipm->ipm.mac_addr, buf, LCS_MAC_LENGTH);
1044 ipm->ipm.ip_addr = im4->multiaddr;
1045 ipm->ipm_state = LCS_IPM_STATE_SET_REQUIRED;
1046 list_add(&ipm->list, &card->ipm_list);
1048 spin_unlock(&card->ipm_lock);
1049 read_unlock(&in4_dev->lock);
1050 in_dev_put(in4_dev);
1051 lcs_fix_multicast_list(card);
1055 * function called by net device to
1056 * handle multicast address relevant things
1059 lcs_set_multicast_list(struct net_device *dev)
1061 struct lcs_card *card;
1063 LCS_DBF_TEXT(4, trace, "setmulti");
1064 card = (struct lcs_card *) dev->priv;
1065 set_bit(3, &card->thread_mask);
1066 schedule_work(&card->kernel_thread_starter);
1069 #endif /* CONFIG_IP_MULTICAST */
1072 lcs_check_irb_error(struct ccw_device *cdev, struct irb *irb)
1077 switch (PTR_ERR(irb)) {
1079 PRINT_WARN("i/o-error on device %s\n", cdev->dev.bus_id);
1080 LCS_DBF_TEXT(2, trace, "ckirberr");
1081 LCS_DBF_TEXT_(2, trace, " rc%d", -EIO);
1084 PRINT_WARN("timeout on device %s\n", cdev->dev.bus_id);
1085 LCS_DBF_TEXT(2, trace, "ckirberr");
1086 LCS_DBF_TEXT_(2, trace, " rc%d", -ETIMEDOUT);
1089 PRINT_WARN("unknown error %ld on device %s\n", PTR_ERR(irb),
1091 LCS_DBF_TEXT(2, trace, "ckirberr");
1092 LCS_DBF_TEXT(2, trace, " rc???");
1094 return PTR_ERR(irb);
1099 * IRQ Handler for LCS channels
1102 lcs_irq(struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
1104 struct lcs_card *card;
1105 struct lcs_channel *channel;
1108 if (lcs_check_irb_error(cdev, irb))
1111 card = CARD_FROM_DEV(cdev);
1112 if (card->read.ccwdev == cdev)
1113 channel = &card->read;
1115 channel = &card->write;
1117 LCS_DBF_TEXT_(5, trace, "Rint%s",cdev->dev.bus_id);
1118 LCS_DBF_TEXT_(5, trace, "%4x%4x",irb->scsw.cstat, irb->scsw.dstat);
1120 /* How far in the ccw chain have we processed? */
1121 if ((channel->state != CH_STATE_INIT) &&
1122 (irb->scsw.fctl & SCSW_FCTL_START_FUNC)) {
1123 index = (struct ccw1 *) __va((addr_t) irb->scsw.cpa)
1125 if ((irb->scsw.actl & SCSW_ACTL_SUSPENDED) ||
1126 (irb->scsw.cstat | SCHN_STAT_PCI))
1127 /* Bloody io subsystem tells us lies about cpa... */
1128 index = (index - 1) & (LCS_NUM_BUFFS - 1);
1129 while (channel->io_idx != index) {
1130 __lcs_processed_buffer(channel,
1131 channel->iob + channel->io_idx);
1133 (channel->io_idx + 1) & (LCS_NUM_BUFFS - 1);
1137 if ((irb->scsw.dstat & DEV_STAT_DEV_END) ||
1138 (irb->scsw.dstat & DEV_STAT_CHN_END) ||
1139 (irb->scsw.dstat & DEV_STAT_UNIT_CHECK))
1140 /* Mark channel as stopped. */
1141 channel->state = CH_STATE_STOPPED;
1142 else if (irb->scsw.actl & SCSW_ACTL_SUSPENDED)
1143 /* CCW execution stopped on a suspend bit. */
1144 channel->state = CH_STATE_SUSPENDED;
1146 if (irb->scsw.fctl & SCSW_FCTL_HALT_FUNC) {
1147 if (irb->scsw.cc != 0) {
1148 ccw_device_halt(channel->ccwdev, (addr_t) channel);
1151 /* The channel has been stopped by halt_IO. */
1152 channel->state = CH_STATE_HALTED;
1155 if (irb->scsw.fctl & SCSW_FCTL_CLEAR_FUNC) {
1156 channel->state = CH_STATE_CLEARED;
1158 /* Do the rest in the tasklet. */
1159 tasklet_schedule(&channel->irq_tasklet);
1163 * Tasklet for IRQ handler
1166 lcs_tasklet(unsigned long data)
1168 unsigned long flags;
1169 struct lcs_channel *channel;
1170 struct lcs_buffer *iob;
1174 channel = (struct lcs_channel *) data;
1175 LCS_DBF_TEXT_(5, trace, "tlet%s",channel->ccwdev->dev.bus_id);
1177 /* Check for processed buffers. */
1179 buf_idx = channel->buf_idx;
1180 while (iob[buf_idx].state == BUF_STATE_PROCESSED) {
1181 /* Do the callback thing. */
1182 if (iob[buf_idx].callback != NULL)
1183 iob[buf_idx].callback(channel, iob + buf_idx);
1184 buf_idx = (buf_idx + 1) & (LCS_NUM_BUFFS - 1);
1186 channel->buf_idx = buf_idx;
1188 if (channel->state == CH_STATE_STOPPED)
1189 // FIXME: what if rc != 0 ??
1190 rc = lcs_start_channel(channel);
1191 spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
1192 if (channel->state == CH_STATE_SUSPENDED &&
1193 channel->iob[channel->io_idx].state == BUF_STATE_READY) {
1194 // FIXME: what if rc != 0 ??
1195 rc = __lcs_resume_channel(channel);
1197 spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
1199 /* Something happened on the channel. Wake up waiters. */
1200 wake_up(&channel->wait_q);
1204 * Finish current tx buffer and make it ready for transmit.
1207 __lcs_emit_txbuffer(struct lcs_card *card)
1209 LCS_DBF_TEXT(5, trace, "emittx");
1210 *(__u16 *)(card->tx_buffer->data + card->tx_buffer->count) = 0;
1211 card->tx_buffer->count += 2;
1212 lcs_ready_buffer(&card->write, card->tx_buffer);
1213 card->tx_buffer = NULL;
1218 * Callback for finished tx buffers.
1221 lcs_txbuffer_cb(struct lcs_channel *channel, struct lcs_buffer *buffer)
1223 struct lcs_card *card;
1225 LCS_DBF_TEXT(5, trace, "txbuffcb");
1226 /* Put buffer back to pool. */
1227 lcs_release_buffer(channel, buffer);
1228 card = (struct lcs_card *)
1229 ((char *) channel - offsetof(struct lcs_card, write));
1230 spin_lock(&card->lock);
1232 if (card->tx_emitted <= 0 && card->tx_buffer != NULL)
1234 * Last running tx buffer has finished. Submit partially
1235 * filled current buffer.
1237 __lcs_emit_txbuffer(card);
1238 spin_unlock(&card->lock);
1242 * Packet transmit function called by network stack
1245 __lcs_start_xmit(struct lcs_card *card, struct sk_buff *skb,
1246 struct net_device *dev)
1248 struct lcs_header *header;
1250 LCS_DBF_TEXT(5, trace, "hardxmit");
1252 card->stats.tx_dropped++;
1253 card->stats.tx_errors++;
1256 if (card->state != DEV_STATE_UP) {
1258 card->stats.tx_dropped++;
1259 card->stats.tx_errors++;
1260 card->stats.tx_carrier_errors++;
1263 if (netif_queue_stopped(dev) ) {
1264 card->stats.tx_dropped++;
1267 if (card->tx_buffer != NULL &&
1268 card->tx_buffer->count + sizeof(struct lcs_header) +
1269 skb->len + sizeof(u16) > LCS_IOBUFFERSIZE)
1270 /* skb too big for current tx buffer. */
1271 __lcs_emit_txbuffer(card);
1272 if (card->tx_buffer == NULL) {
1273 /* Get new tx buffer */
1274 card->tx_buffer = lcs_get_buffer(&card->write);
1275 if (card->tx_buffer == NULL) {
1276 card->stats.tx_dropped++;
1279 card->tx_buffer->callback = lcs_txbuffer_cb;
1280 card->tx_buffer->count = 0;
1282 header = (struct lcs_header *)
1283 (card->tx_buffer->data + card->tx_buffer->count);
1284 card->tx_buffer->count += skb->len + sizeof(struct lcs_header);
1285 header->offset = card->tx_buffer->count;
1286 header->type = card->lan_type;
1287 header->slot = card->portno;
1288 memcpy(header + 1, skb->data, skb->len);
1289 card->stats.tx_bytes += skb->len;
1290 card->stats.tx_packets++;
1292 if (card->tx_emitted <= 0)
1293 /* If this is the first tx buffer emit it immediately. */
1294 __lcs_emit_txbuffer(card);
1299 lcs_start_xmit(struct sk_buff *skb, struct net_device *dev)
1301 struct lcs_card *card;
1304 LCS_DBF_TEXT(5, trace, "pktxmit");
1305 card = (struct lcs_card *) dev->priv;
1306 spin_lock(&card->lock);
1307 rc = __lcs_start_xmit(card, skb, dev);
1308 spin_unlock(&card->lock);
1313 * send startlan and lanstat command to make LCS device ready
1316 lcs_startlan_auto(struct lcs_card *card)
1320 LCS_DBF_TEXT(2, trace, "strtauto");
1321 #ifdef CONFIG_NET_ETHERNET
1322 card->lan_type = LCS_FRAME_TYPE_ENET;
1323 rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP);
1329 card->lan_type = LCS_FRAME_TYPE_TR;
1330 rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP);
1335 card->lan_type = LCS_FRAME_TYPE_FDDI;
1336 rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP);
1344 lcs_startlan(struct lcs_card *card)
1348 LCS_DBF_TEXT(2, trace, "startlan");
1350 if (card->portno != LCS_INVALID_PORT_NO) {
1351 if (card->lan_type == LCS_FRAME_TYPE_AUTO)
1352 rc = lcs_startlan_auto(card);
1354 rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP);
1356 for (i = 0; i <= 16; i++) {
1358 if (card->lan_type != LCS_FRAME_TYPE_AUTO)
1359 rc = lcs_send_startlan(card,
1360 LCS_INITIATOR_TCPIP);
1362 /* autodetecting lan type */
1363 rc = lcs_startlan_auto(card);
1369 return lcs_send_lanstat(card);
1374 * LCS detect function
1375 * setup channels and make them I/O ready
1378 lcs_detect(struct lcs_card *card)
1382 LCS_DBF_TEXT(2, setup, "lcsdetct");
1383 /* start/reset card */
1385 netif_stop_queue(card->dev);
1386 card->write.state = CH_STATE_INIT;
1387 card->read.state = CH_STATE_INIT;
1388 rc = lcs_stop_channels(card);
1390 rc = lcs_start_channels(card);
1392 rc = lcs_send_startup(card, LCS_INITIATOR_TCPIP);
1394 rc = lcs_startlan(card);
1398 card->state = DEV_STATE_UP;
1400 card->state = DEV_STATE_DOWN;
1401 card->write.state = CH_STATE_INIT;
1402 card->read.state = CH_STATE_INIT;
1411 lcs_resetcard(struct lcs_card *card)
1415 LCS_DBF_TEXT(2, trace, "rescard");
1416 for (retries = 0; retries < 10; retries++) {
1417 if (lcs_detect(card) == 0) {
1418 netif_wake_queue(card->dev);
1419 card->state = DEV_STATE_UP;
1420 PRINT_INFO("LCS device %s successfully restarted!\n",
1426 PRINT_ERR("Error in Reseting LCS card!\n");
1434 lcs_stopcard(struct lcs_card *card)
1438 LCS_DBF_TEXT(3, setup, "stopcard");
1440 if (card->read.state != CH_STATE_STOPPED &&
1441 card->write.state != CH_STATE_STOPPED &&
1442 card->state == DEV_STATE_UP) {
1443 rc = lcs_send_stoplan(card,LCS_INITIATOR_TCPIP);
1444 rc = lcs_send_shutdown(card);
1446 rc = lcs_stop_channels(card);
1447 card->state = DEV_STATE_DOWN;
1453 * LGW initiated commands
1456 lcs_lgw_startlan_thread(void *data)
1458 struct lcs_card *card;
1460 card = (struct lcs_card *) data;
1461 daemonize("lgwstpln");
1462 LCS_DBF_TEXT(4, trace, "lgwstpln");
1464 netif_stop_queue(card->dev);
1465 if (lcs_startlan(card) == 0) {
1466 netif_wake_queue(card->dev);
1467 card->state = DEV_STATE_UP;
1468 PRINT_INFO("LCS Startlan for device %s succeeded!\n",
1472 PRINT_ERR("LCS Startlan for device %s failed!\n",
1478 * Send startup command initiated by Lan Gateway
1481 lcs_lgw_startup_thread(void *data)
1485 struct lcs_card *card;
1487 card = (struct lcs_card *) data;
1488 daemonize("lgwstpln");
1489 LCS_DBF_TEXT(4, trace, "lgwstpln");
1491 netif_stop_queue(card->dev);
1492 rc = lcs_send_startup(card, LCS_INITIATOR_LGW);
1494 PRINT_ERR("Startup for LCS device %s initiated " \
1495 "by LGW failed!\nReseting card ...\n",
1497 /* do a card reset */
1498 rc = lcs_resetcard(card);
1502 rc = lcs_startlan(card);
1504 netif_wake_queue(card->dev);
1505 card->state = DEV_STATE_UP;
1509 PRINT_INFO("LCS Startup for device %s succeeded!\n",
1512 PRINT_ERR("LCS Startup for device %s failed!\n",
1519 * send stoplan command initiated by Lan Gateway
1522 lcs_lgw_stoplan_thread(void *data)
1524 struct lcs_card *card;
1527 card = (struct lcs_card *) data;
1528 daemonize("lgwstop");
1529 LCS_DBF_TEXT(4, trace, "lgwstop");
1531 netif_stop_queue(card->dev);
1532 if (lcs_send_stoplan(card, LCS_INITIATOR_LGW) == 0)
1533 PRINT_INFO("Stoplan for %s initiated by LGW succeeded!\n",
1536 PRINT_ERR("Stoplan %s initiated by LGW failed!\n",
1538 /*Try to reset the card, stop it on failure */
1539 rc = lcs_resetcard(card);
1541 rc = lcs_stopcard(card);
1546 * Kernel Thread helper functions for LGW initiated commands
1549 lcs_start_kernel_thread(struct lcs_card *card)
1551 LCS_DBF_TEXT(5, trace, "krnthrd");
1552 if (test_and_clear_bit(0, &card->thread_mask))
1553 kernel_thread(lcs_lgw_startup_thread, (void *) card, SIGCHLD);
1554 if (test_and_clear_bit(1, &card->thread_mask))
1555 kernel_thread(lcs_lgw_startlan_thread, (void *) card, SIGCHLD);
1556 if (test_and_clear_bit(2, &card->thread_mask))
1557 kernel_thread(lcs_lgw_stoplan_thread, (void *) card, SIGCHLD);
1558 #ifdef CONFIG_IP_MULTICAST
1559 if (test_and_clear_bit(3, &card->thread_mask))
1560 kernel_thread(lcs_register_mc_addresses, (void *) card, SIGCHLD);
1565 * Process control frames.
1568 lcs_get_control(struct lcs_card *card, struct lcs_cmd *cmd)
1570 LCS_DBF_TEXT(5, trace, "getctrl");
1571 if (cmd->initiator == LCS_INITIATOR_LGW) {
1572 switch(cmd->cmd_code) {
1573 case LCS_CMD_STARTUP:
1574 set_bit(0, &card->thread_mask);
1575 schedule_work(&card->kernel_thread_starter);
1577 case LCS_CMD_STARTLAN:
1578 set_bit(1, &card->thread_mask);
1579 schedule_work(&card->kernel_thread_starter);
1581 case LCS_CMD_STOPLAN:
1582 set_bit(2, &card->thread_mask);
1583 schedule_work(&card->kernel_thread_starter);
1586 PRINT_INFO("UNRECOGNIZED LGW COMMAND\n");
1590 lcs_notify_lancmd_waiters(card, cmd);
1594 * Unpack network packet.
1597 lcs_get_skb(struct lcs_card *card, char *skb_data, unsigned int skb_len)
1599 struct sk_buff *skb;
1601 LCS_DBF_TEXT(5, trace, "getskb");
1602 if (card->dev == NULL ||
1603 card->state != DEV_STATE_UP)
1604 /* The card isn't up. Ignore the packet. */
1607 skb = dev_alloc_skb(skb_len);
1609 PRINT_ERR("LCS: alloc_skb failed for device=%s\n",
1611 card->stats.rx_dropped++;
1614 skb->dev = card->dev;
1615 memcpy(skb_put(skb, skb_len), skb_data, skb_len);
1616 skb->protocol = card->lan_type_trans(skb, card->dev);
1617 card->stats.rx_bytes += skb_len;
1618 card->stats.rx_packets++;
1623 * LCS main routine to get packets and lancmd replies from the buffers
1626 lcs_get_frames_cb(struct lcs_channel *channel, struct lcs_buffer *buffer)
1628 struct lcs_card *card;
1629 struct lcs_header *lcs_hdr;
1632 LCS_DBF_TEXT(5, trace, "lcsgtpkt");
1633 lcs_hdr = (struct lcs_header *) buffer->data;
1634 if (lcs_hdr->offset == LCS_ILLEGAL_OFFSET) {
1635 LCS_DBF_TEXT(4, trace, "-eiogpkt");
1638 card = (struct lcs_card *)
1639 ((char *) channel - offsetof(struct lcs_card, read));
1641 while (lcs_hdr->offset != 0) {
1642 if (lcs_hdr->offset <= 0 ||
1643 lcs_hdr->offset > LCS_IOBUFFERSIZE ||
1644 lcs_hdr->offset < offset) {
1645 /* Offset invalid. */
1646 card->stats.rx_length_errors++;
1647 card->stats.rx_errors++;
1650 /* What kind of frame is it? */
1651 if (lcs_hdr->type == LCS_FRAME_TYPE_CONTROL)
1652 /* Control frame. */
1653 lcs_get_control(card, (struct lcs_cmd *) lcs_hdr);
1654 else if (lcs_hdr->type == LCS_FRAME_TYPE_ENET ||
1655 lcs_hdr->type == LCS_FRAME_TYPE_TR ||
1656 lcs_hdr->type == LCS_FRAME_TYPE_FDDI)
1657 /* Normal network packet. */
1658 lcs_get_skb(card, (char *)(lcs_hdr + 1),
1659 lcs_hdr->offset - offset -
1660 sizeof(struct lcs_header));
1662 /* Unknown frame type. */
1663 ; // FIXME: error message ?
1664 /* Proceed to next frame. */
1665 offset = lcs_hdr->offset;
1666 lcs_hdr->offset = LCS_ILLEGAL_OFFSET;
1667 lcs_hdr = (struct lcs_header *) (buffer->data + offset);
1669 /* The buffer is now empty. Make it ready again. */
1670 lcs_ready_buffer(&card->read, buffer);
1674 * get network statistics for ifconfig and other user programs
1676 static struct net_device_stats *
1677 lcs_getstats(struct net_device *dev)
1679 struct lcs_card *card;
1681 LCS_DBF_TEXT(4, trace, "netstats");
1682 card = (struct lcs_card *) dev->priv;
1683 return &card->stats;
1688 * This function will be called by user doing ifconfig xxx down
1691 lcs_stop_device(struct net_device *dev)
1693 struct lcs_card *card;
1696 LCS_DBF_TEXT(2, trace, "stopdev");
1697 card = (struct lcs_card *) dev->priv;
1698 netif_stop_queue(dev);
1699 dev->flags &= ~IFF_UP;
1700 rc = lcs_stopcard(card);
1702 PRINT_ERR("Try it again!\n ");
1707 * start lcs device and make it runnable
1708 * This function will be called by user doing ifconfig xxx up
1711 lcs_open_device(struct net_device *dev)
1713 struct lcs_card *card;
1716 LCS_DBF_TEXT(2, trace, "opendev");
1717 card = (struct lcs_card *) dev->priv;
1718 /* initialize statistics */
1719 rc = lcs_detect(card);
1721 PRINT_ERR("LCS:Error in opening device!\n");
1724 dev->flags |= IFF_UP;
1725 netif_wake_queue(dev);
1726 card->state = DEV_STATE_UP;
1732 * show function for portno called by cat or similar things
1735 lcs_portno_show (struct device *dev, char *buf)
1737 struct lcs_card *card;
1739 card = (struct lcs_card *)dev->driver_data;
1744 return sprintf(buf, "%d\n", card->portno);
1748 * store the value which is piped to file portno
1751 lcs_portno_store (struct device *dev, const char *buf, size_t count)
1753 struct lcs_card *card;
1756 card = (struct lcs_card *)dev->driver_data;
1761 sscanf(buf, "%u", &value);
1762 /* TODO: sanity checks */
1763 card->portno = value;
1769 static DEVICE_ATTR(portno, 0644, lcs_portno_show, lcs_portno_store);
1772 lcs_type_show(struct device *dev, char *buf)
1774 struct ccwgroup_device *cgdev;
1776 cgdev = to_ccwgroupdev(dev);
1780 return sprintf(buf, "%s\n", cu3088_type[cgdev->cdev[0]->id.driver_info]);
1783 static DEVICE_ATTR(type, 0444, lcs_type_show, NULL);
1786 lcs_timeout_show(struct device *dev, char *buf)
1788 struct lcs_card *card;
1790 card = (struct lcs_card *)dev->driver_data;
1792 return card ? sprintf(buf, "%u\n", card->lancmd_timeout) : 0;
1796 lcs_timeout_store (struct device *dev, const char *buf, size_t count)
1798 struct lcs_card *card;
1801 card = (struct lcs_card *)dev->driver_data;
1806 sscanf(buf, "%u", &value);
1807 /* TODO: sanity checks */
1808 card->lancmd_timeout = value;
1814 DEVICE_ATTR(lancmd_timeout, 0644, lcs_timeout_show, lcs_timeout_store);
1816 static struct attribute * lcs_attrs[] = {
1817 &dev_attr_portno.attr,
1818 &dev_attr_type.attr,
1819 &dev_attr_lancmd_timeout.attr,
1823 static struct attribute_group lcs_attr_group = {
1828 * lcs_probe_device is called on establishing a new ccwgroup_device.
1831 lcs_probe_device(struct ccwgroup_device *ccwgdev)
1833 struct lcs_card *card;
1836 if (!get_device(&ccwgdev->dev))
1839 LCS_DBF_TEXT(2, setup, "add_dev");
1840 card = lcs_alloc_card();
1842 PRINT_ERR("Allocation of lcs card failed\n");
1843 put_device(&ccwgdev->dev);
1846 ret = sysfs_create_group(&ccwgdev->dev.kobj, &lcs_attr_group);
1848 PRINT_ERR("Creating attributes failed");
1849 lcs_free_card(card);
1850 put_device(&ccwgdev->dev);
1853 ccwgdev->dev.driver_data = card;
1854 ccwgdev->cdev[0]->handler = lcs_irq;
1855 ccwgdev->cdev[1]->handler = lcs_irq;
1860 lcs_register_netdev(struct ccwgroup_device *ccwgdev)
1862 struct lcs_card *card;
1864 LCS_DBF_TEXT(2, setup, "regnetdv");
1865 card = (struct lcs_card *)ccwgdev->dev.driver_data;
1866 if (card->dev->reg_state != NETREG_UNINITIALIZED)
1868 SET_NETDEV_DEV(card->dev, &ccwgdev->dev);
1869 return register_netdev(card->dev);
1873 * lcs_new_device will be called by setting the group device online.
1877 lcs_new_device(struct ccwgroup_device *ccwgdev)
1879 struct lcs_card *card;
1880 struct net_device *dev=NULL;
1881 enum lcs_dev_states recover_state;
1884 card = (struct lcs_card *)ccwgdev->dev.driver_data;
1888 LCS_DBF_TEXT(2, setup, "newdev");
1889 LCS_DBF_HEX(3, setup, &card, sizeof(void*));
1890 card->read.ccwdev = ccwgdev->cdev[0];
1891 card->write.ccwdev = ccwgdev->cdev[1];
1893 recover_state = card->state;
1894 ccw_device_set_online(card->read.ccwdev);
1895 ccw_device_set_online(card->write.ccwdev);
1897 LCS_DBF_TEXT(3, setup, "lcsnewdv");
1899 lcs_setup_card(card);
1900 rc = lcs_detect(card);
1902 LCS_DBF_TEXT(2, setup, "dtctfail");
1903 PRINT_WARN("Detection of LCS card failed with return code "
1904 "%d (0x%x)\n", rc, rc);
1909 LCS_DBF_TEXT(2, setup, "samedev");
1910 LCS_DBF_HEX(3, setup, &card, sizeof(void*));
1913 switch (card->lan_type) {
1914 #ifdef CONFIG_NET_ETHERNET
1915 case LCS_FRAME_TYPE_ENET:
1916 card->lan_type_trans = eth_type_trans;
1917 dev = alloc_etherdev(0);
1921 case LCS_FRAME_TYPE_TR:
1922 card->lan_type_trans = tr_type_trans;
1923 dev = alloc_trdev(0);
1927 case LCS_FRAME_TYPE_FDDI:
1928 card->lan_type_trans = fddi_type_trans;
1929 dev = alloc_fddidev(0);
1933 LCS_DBF_TEXT(3, setup, "errinit");
1934 PRINT_ERR("LCS: Initialization failed\n");
1935 PRINT_ERR("LCS: No device found!\n");
1942 card->dev->priv = card;
1943 card->dev->open = lcs_open_device;
1944 card->dev->stop = lcs_stop_device;
1945 card->dev->hard_start_xmit = lcs_start_xmit;
1946 card->dev->get_stats = lcs_getstats;
1947 SET_MODULE_OWNER(dev);
1948 if (lcs_register_netdev(ccwgdev) != 0)
1950 memcpy(card->dev->dev_addr, card->mac, LCS_MAC_LENGTH);
1951 #ifdef CONFIG_IP_MULTICAST
1952 if (!lcs_check_multicast_support(card))
1953 card->dev->set_multicast_list = lcs_set_multicast_list;
1955 netif_stop_queue(card->dev);
1956 if (recover_state == DEV_STATE_RECOVER) {
1957 card->dev->flags |= IFF_UP;
1958 netif_wake_queue(card->dev);
1959 card->state = DEV_STATE_UP;
1966 ccw_device_set_offline(card->read.ccwdev);
1967 ccw_device_set_offline(card->write.ccwdev);
1972 * lcs_shutdown_device, called when setting the group device offline.
1975 lcs_shutdown_device(struct ccwgroup_device *ccwgdev)
1977 struct lcs_card *card;
1978 enum lcs_dev_states recover_state;
1981 LCS_DBF_TEXT(3, setup, "shtdndev");
1982 card = (struct lcs_card *)ccwgdev->dev.driver_data;
1986 LCS_DBF_HEX(3, setup, &card, sizeof(void*));
1987 recover_state = card->state;
1989 ret = lcs_stop_device(card->dev);
1990 ret = ccw_device_set_offline(card->read.ccwdev);
1991 ret = ccw_device_set_offline(card->write.ccwdev);
1992 if (recover_state == DEV_STATE_UP) {
1993 card->state = DEV_STATE_RECOVER;
2001 * lcs_remove_device, free buffers and card
2004 lcs_remove_device(struct ccwgroup_device *ccwgdev)
2006 struct lcs_card *card;
2008 card = (struct lcs_card *)ccwgdev->dev.driver_data;
2012 PRINT_INFO("Removing lcs group device ....\n");
2013 LCS_DBF_TEXT(3, setup, "remdev");
2014 LCS_DBF_HEX(3, setup, &card, sizeof(void*));
2015 if (ccwgdev->state == CCWGROUP_ONLINE) {
2016 lcs_shutdown_device(ccwgdev);
2019 unregister_netdev(card->dev);
2020 sysfs_remove_group(&ccwgdev->dev.kobj, &lcs_attr_group);
2021 lcs_cleanup_card(card);
2022 lcs_free_card(card);
2023 put_device(&ccwgdev->dev);
2027 * LCS ccwgroup driver registration
2029 static struct ccwgroup_driver lcs_group_driver = {
2030 .owner = THIS_MODULE,
2033 .driver_id = 0xD3C3E2,
2034 .probe = lcs_probe_device,
2035 .remove = lcs_remove_device,
2036 .set_online = lcs_new_device,
2037 .set_offline = lcs_shutdown_device,
2041 * LCS Module/Kernel initialization function
2044 __init lcs_init_module(void)
2048 PRINT_INFO("Loading %s\n",version);
2049 rc = lcs_register_debug_facility();
2050 LCS_DBF_TEXT(0, setup, "lcsinit");
2052 PRINT_ERR("Initialization failed\n");
2056 rc = register_cu3088_discipline(&lcs_group_driver);
2058 PRINT_ERR("Initialization failed\n");
2067 * LCS module cleanup function
2070 __exit lcs_cleanup_module(void)
2072 PRINT_INFO("Terminating lcs module.\n");
2073 LCS_DBF_TEXT(0, trace, "cleanup");
2074 unregister_cu3088_discipline(&lcs_group_driver);
2075 lcs_unregister_debug_facility();
2078 module_init(lcs_init_module);
2079 module_exit(lcs_cleanup_module);
2081 MODULE_AUTHOR("Frank Pavlic <pavlic@de.ibm.com>");
2082 MODULE_LICENSE("GPL");