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.81 $ $Date: 2004/05/14 13:54:33 $
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>
43 #include <asm/debug.h>
44 #include <asm/idals.h>
45 #include <asm/timex.h>
46 #include <linux/device.h>
47 #include <asm/ccwgroup.h>
53 #if !defined(CONFIG_NET_ETHERNET) && \
54 !defined(CONFIG_TR) && !defined(CONFIG_FDDI)
55 #error Cannot compile lcs.c without some net devices switched on.
59 * initialization string for output
61 #define VERSION_LCS_C "$Revision: 1.81 $"
63 static char version[] __initdata = "LCS driver ("VERSION_LCS_C "/" VERSION_LCS_H ")";
64 static char debug_buffer[255];
69 static void lcs_tasklet(unsigned long);
70 static void lcs_start_kernel_thread(struct lcs_card *card);
71 static void lcs_get_frames_cb(struct lcs_channel *, struct lcs_buffer *);
74 * Debug Facility Stuff
76 static debug_info_t *lcs_dbf_setup;
77 static debug_info_t *lcs_dbf_trace;
80 * LCS Debug Facility functions
83 lcs_unregister_debug_facility(void)
86 debug_unregister(lcs_dbf_setup);
88 debug_unregister(lcs_dbf_trace);
92 lcs_register_debug_facility(void)
94 lcs_dbf_setup = debug_register("lcs_setup", 1, 1, 8);
95 lcs_dbf_trace = debug_register("lcs_trace", 1, 2, 8);
96 if (lcs_dbf_setup == NULL || lcs_dbf_trace == NULL) {
97 PRINT_ERR("Not enough memory for debug facility.\n");
98 lcs_unregister_debug_facility();
101 debug_register_view(lcs_dbf_setup, &debug_hex_ascii_view);
102 debug_set_level(lcs_dbf_setup, 2);
103 debug_register_view(lcs_dbf_trace, &debug_hex_ascii_view);
104 debug_set_level(lcs_dbf_trace, 2);
109 * Allocate io buffers.
112 lcs_alloc_channel(struct lcs_channel *channel)
116 LCS_DBF_TEXT(2, setup, "ichalloc");
117 for (cnt = 0; cnt < LCS_NUM_BUFFS; cnt++) {
118 /* alloc memory fo iobuffer */
119 channel->iob[cnt].data = (void *)
120 kmalloc(LCS_IOBUFFERSIZE, GFP_DMA | GFP_KERNEL);
121 if (channel->iob[cnt].data == NULL)
123 memset(channel->iob[cnt].data, 0, LCS_IOBUFFERSIZE);
124 channel->iob[cnt].state = BUF_STATE_EMPTY;
126 if (cnt < LCS_NUM_BUFFS) {
127 /* Not all io buffers could be allocated. */
128 LCS_DBF_TEXT(2, setup, "echalloc");
130 kfree(channel->iob[cnt].data);
140 lcs_free_channel(struct lcs_channel *channel)
144 LCS_DBF_TEXT(2, setup, "ichfree");
145 for (cnt = 0; cnt < LCS_NUM_BUFFS; cnt++) {
146 if (channel->iob[cnt].data != NULL)
147 kfree(channel->iob[cnt].data);
148 channel->iob[cnt].data = NULL;
156 lcs_cleanup_channel(struct lcs_channel *channel)
158 LCS_DBF_TEXT(3, setup, "cleanch");
159 /* Kill write channel tasklets. */
160 tasklet_kill(&channel->irq_tasklet);
161 /* Free channel buffers. */
162 lcs_free_channel(channel);
166 * LCS free memory for card and channels.
169 lcs_free_card(struct lcs_card *card)
171 LCS_DBF_TEXT(2, setup, "remcard");
172 LCS_DBF_HEX(2, setup, &card, sizeof(void*));
177 * LCS alloc memory for card and channels
179 static struct lcs_card *
182 struct lcs_card *card;
185 LCS_DBF_TEXT(2, setup, "alloclcs");
187 card = kmalloc(sizeof(struct lcs_card), GFP_KERNEL | GFP_DMA);
190 memset(card, 0, sizeof(struct lcs_card));
191 card->lan_type = LCS_FRAME_TYPE_AUTO;
192 card->lancmd_timeout = LCS_LANCMD_TIMEOUT_DEFAULT;
193 /* Allocate io buffers for the read channel. */
194 rc = lcs_alloc_channel(&card->read);
196 LCS_DBF_TEXT(2, setup, "iccwerr");
200 /* Allocate io buffers for the write channel. */
201 rc = lcs_alloc_channel(&card->write);
203 LCS_DBF_TEXT(2, setup, "iccwerr");
204 lcs_cleanup_channel(&card->read);
209 #ifdef CONFIG_IP_MULTICAST
210 INIT_LIST_HEAD(&card->ipm_list);
212 LCS_DBF_HEX(2, setup, &card, sizeof(void*));
217 * Setup read channel.
220 lcs_setup_read_ccws(struct lcs_card *card)
224 LCS_DBF_TEXT(2, setup, "ireadccw");
225 /* Setup read ccws. */
226 memset(card->read.ccws, 0, sizeof (struct ccw1) * (LCS_NUM_BUFFS + 1));
227 for (cnt = 0; cnt < LCS_NUM_BUFFS; cnt++) {
228 card->read.ccws[cnt].cmd_code = LCS_CCW_READ;
229 card->read.ccws[cnt].count = LCS_IOBUFFERSIZE;
230 card->read.ccws[cnt].flags =
231 CCW_FLAG_CC | CCW_FLAG_SLI | CCW_FLAG_PCI;
233 * Note: we have allocated the buffer with GFP_DMA, so
234 * we do not need to do set_normalized_cda.
236 card->read.ccws[cnt].cda =
237 (__u32) __pa(card->read.iob[cnt].data);
238 ((struct lcs_header *)
239 card->read.iob[cnt].data)->offset = LCS_ILLEGAL_OFFSET;
240 card->read.iob[cnt].callback = lcs_get_frames_cb;
241 card->read.iob[cnt].state = BUF_STATE_READY;
242 card->read.iob[cnt].count = LCS_IOBUFFERSIZE;
244 card->read.ccws[0].flags &= ~CCW_FLAG_PCI;
245 card->read.ccws[LCS_NUM_BUFFS - 1].flags &= ~CCW_FLAG_PCI;
246 card->read.ccws[LCS_NUM_BUFFS - 1].flags |= CCW_FLAG_SUSPEND;
247 /* Last ccw is a tic (transfer in channel). */
248 card->read.ccws[LCS_NUM_BUFFS].cmd_code = LCS_CCW_TRANSFER;
249 card->read.ccws[LCS_NUM_BUFFS].cda =
250 (__u32) __pa(card->read.ccws);
251 /* Setg initial state of the read channel. */
252 card->read.state = CH_STATE_INIT;
254 card->read.io_idx = 0;
255 card->read.buf_idx = 0;
259 lcs_setup_read(struct lcs_card *card)
261 LCS_DBF_TEXT(3, setup, "initread");
263 lcs_setup_read_ccws(card);
264 /* Initialize read channel tasklet. */
265 card->read.irq_tasklet.data = (unsigned long) &card->read;
266 card->read.irq_tasklet.func = lcs_tasklet;
267 /* Initialize waitqueue. */
268 init_waitqueue_head(&card->read.wait_q);
272 * Setup write channel.
275 lcs_setup_write_ccws(struct lcs_card *card)
279 LCS_DBF_TEXT(3, setup, "iwritccw");
280 /* Setup write ccws. */
281 memset(card->write.ccws, 0, sizeof(struct ccw1) * LCS_NUM_BUFFS + 1);
282 for (cnt = 0; cnt < LCS_NUM_BUFFS; cnt++) {
283 card->write.ccws[cnt].cmd_code = LCS_CCW_WRITE;
284 card->write.ccws[cnt].count = 0;
285 card->write.ccws[cnt].flags =
286 CCW_FLAG_SUSPEND | CCW_FLAG_CC | CCW_FLAG_SLI;
288 * Note: we have allocated the buffer with GFP_DMA, so
289 * we do not need to do set_normalized_cda.
291 card->write.ccws[cnt].cda =
292 (__u32) __pa(card->write.iob[cnt].data);
294 /* Last ccw is a tic (transfer in channel). */
295 card->write.ccws[LCS_NUM_BUFFS].cmd_code = LCS_CCW_TRANSFER;
296 card->write.ccws[LCS_NUM_BUFFS].cda =
297 (__u32) __pa(card->write.ccws);
298 /* Set initial state of the write channel. */
299 card->read.state = CH_STATE_INIT;
301 card->write.io_idx = 0;
302 card->write.buf_idx = 0;
306 lcs_setup_write(struct lcs_card *card)
308 LCS_DBF_TEXT(3, setup, "initwrit");
310 lcs_setup_write_ccws(card);
311 /* Initialize write channel tasklet. */
312 card->write.irq_tasklet.data = (unsigned long) &card->write;
313 card->write.irq_tasklet.func = lcs_tasklet;
314 /* Initialize waitqueue. */
315 init_waitqueue_head(&card->write.wait_q);
321 * Initialize channels,card and state machines.
324 lcs_setup_card(struct lcs_card *card)
326 LCS_DBF_TEXT(2, setup, "initcard");
327 LCS_DBF_HEX(2, setup, &card, sizeof(void*));
329 lcs_setup_read(card);
330 lcs_setup_write(card);
331 /* Set cards initial state. */
332 card->state = DEV_STATE_DOWN;
333 card->tx_buffer = NULL;
334 card->tx_emitted = 0;
336 /* Initialize kernel thread task used for LGW commands. */
337 INIT_WORK(&card->kernel_thread_starter,
338 (void *)lcs_start_kernel_thread,card);
339 card->thread_mask = 0;
340 spin_lock_init(&card->lock);
341 spin_lock_init(&card->ipm_lock);
342 #ifdef CONFIG_IP_MULTICAST
343 INIT_LIST_HEAD(&card->ipm_list);
345 INIT_LIST_HEAD(&card->lancmd_waiters);
349 * Cleanup channels,card and state machines.
352 lcs_cleanup_card(struct lcs_card *card)
354 struct list_head *l, *n;
355 struct lcs_ipm_list *ipm_list;
357 LCS_DBF_TEXT(3, setup, "cleancrd");
358 LCS_DBF_HEX(2,setup,&card,sizeof(void*));
359 #ifdef CONFIG_IP_MULTICAST
360 /* Free multicast list. */
361 list_for_each_safe(l, n, &card->ipm_list) {
362 ipm_list = list_entry(l, struct lcs_ipm_list, list);
363 list_del(&ipm_list->list);
367 if (card->dev != NULL)
368 free_netdev(card->dev);
369 /* Cleanup channels. */
370 lcs_cleanup_channel(&card->write);
371 lcs_cleanup_channel(&card->read);
378 lcs_start_channel(struct lcs_channel *channel)
383 LCS_DBF_TEXT_(4,trace,"ssch%s", channel->ccwdev->dev.bus_id);
384 spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
385 rc = ccw_device_start(channel->ccwdev,
386 channel->ccws + channel->io_idx, 0, 0,
387 DOIO_DENY_PREFETCH | DOIO_ALLOW_SUSPEND);
389 channel->state = CH_STATE_RUNNING;
390 spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
392 LCS_DBF_TEXT_(4,trace,"essh%s", channel->ccwdev->dev.bus_id);
393 PRINT_ERR("Error in starting channel, rc=%d!\n", rc);
399 lcs_clear_channel(struct lcs_channel *channel)
404 LCS_DBF_TEXT(4,trace,"clearch");
405 LCS_DBF_TEXT_(4,trace,"%s", channel->ccwdev->dev.bus_id);
406 spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
407 rc = ccw_device_clear(channel->ccwdev, (addr_t) channel);
408 spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
410 LCS_DBF_TEXT_(4,trace,"ecsc%s", channel->ccwdev->dev.bus_id);
413 wait_event(channel->wait_q, (channel->state == CH_STATE_CLEARED));
414 channel->state = CH_STATE_STOPPED;
423 lcs_stop_channel(struct lcs_channel *channel)
428 if (channel->state == CH_STATE_STOPPED)
430 LCS_DBF_TEXT(4,trace,"haltsch");
431 LCS_DBF_TEXT_(4,trace,"%s", channel->ccwdev->dev.bus_id);
432 spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
433 rc = ccw_device_halt(channel->ccwdev, (addr_t) channel);
434 spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
436 LCS_DBF_TEXT_(4,trace,"ehsc%s", channel->ccwdev->dev.bus_id);
439 /* Asynchronous halt initialted. Wait for its completion. */
440 wait_event(channel->wait_q, (channel->state == CH_STATE_HALTED));
441 lcs_clear_channel(channel);
446 * start read and write channel
449 lcs_start_channels(struct lcs_card *card)
453 LCS_DBF_TEXT(2, trace, "chstart");
454 /* start read channel */
455 rc = lcs_start_channel(&card->read);
458 /* start write channel */
459 rc = lcs_start_channel(&card->write);
461 lcs_stop_channel(&card->read);
466 * stop read and write channel
469 lcs_stop_channels(struct lcs_card *card)
471 LCS_DBF_TEXT(2, trace, "chhalt");
472 lcs_stop_channel(&card->read);
473 lcs_stop_channel(&card->write);
480 static struct lcs_buffer *
481 __lcs_get_buffer(struct lcs_channel *channel)
485 LCS_DBF_TEXT(5, trace, "_getbuff");
486 index = channel->io_idx;
488 if (channel->iob[index].state == BUF_STATE_EMPTY) {
489 channel->iob[index].state = BUF_STATE_LOCKED;
490 return channel->iob + index;
492 index = (index + 1) & (LCS_NUM_BUFFS - 1);
493 } while (index != channel->io_idx);
497 static struct lcs_buffer *
498 lcs_get_buffer(struct lcs_channel *channel)
500 struct lcs_buffer *buffer;
503 LCS_DBF_TEXT(5, trace, "getbuff");
504 spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
505 buffer = __lcs_get_buffer(channel);
506 spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
511 * Resume channel program if the channel is suspended.
514 __lcs_resume_channel(struct lcs_channel *channel)
518 if (channel->state != CH_STATE_SUSPENDED)
520 if (channel->ccws[channel->io_idx].flags & CCW_FLAG_SUSPEND)
522 LCS_DBF_TEXT_(5, trace, "rsch%s", channel->ccwdev->dev.bus_id);
523 rc = ccw_device_resume(channel->ccwdev);
525 LCS_DBF_TEXT_(4, trace, "ersc%s", channel->ccwdev->dev.bus_id);
526 PRINT_ERR("Error in lcs_resume_channel: rc=%d\n",rc);
528 channel->state = CH_STATE_RUNNING;
534 * Make a buffer ready for processing.
537 __lcs_ready_buffer_bits(struct lcs_channel *channel, int index)
541 LCS_DBF_TEXT(5, trace, "rdybits");
542 prev = (index - 1) & (LCS_NUM_BUFFS - 1);
543 next = (index + 1) & (LCS_NUM_BUFFS - 1);
544 /* Check if we may clear the suspend bit of this buffer. */
545 if (channel->ccws[next].flags & CCW_FLAG_SUSPEND) {
546 /* Check if we have to set the PCI bit. */
547 if (!(channel->ccws[prev].flags & CCW_FLAG_SUSPEND))
548 /* Suspend bit of the previous buffer is not set. */
549 channel->ccws[index].flags |= CCW_FLAG_PCI;
550 /* Suspend bit of the next buffer is set. */
551 channel->ccws[index].flags &= ~CCW_FLAG_SUSPEND;
556 lcs_ready_buffer(struct lcs_channel *channel, struct lcs_buffer *buffer)
561 LCS_DBF_TEXT(5, trace, "rdybuff");
562 if (buffer->state != BUF_STATE_LOCKED &&
563 buffer->state != BUF_STATE_PROCESSED)
565 spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
566 buffer->state = BUF_STATE_READY;
567 index = buffer - channel->iob;
569 channel->ccws[index].count = buffer->count;
570 /* Check relevant PCI/suspend bits. */
571 __lcs_ready_buffer_bits(channel, index);
572 rc = __lcs_resume_channel(channel);
573 spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
578 * Mark the buffer as processed. Take care of the suspend bit
579 * of the previous buffer. This function is called from
580 * interrupt context, so the lock must not be taken.
583 __lcs_processed_buffer(struct lcs_channel *channel, struct lcs_buffer *buffer)
585 int index, prev, next;
587 LCS_DBF_TEXT(5, trace, "prcsbuff");
588 if (buffer->state != BUF_STATE_READY)
590 buffer->state = BUF_STATE_PROCESSED;
591 index = buffer - channel->iob;
592 prev = (index - 1) & (LCS_NUM_BUFFS - 1);
593 next = (index + 1) & (LCS_NUM_BUFFS - 1);
594 /* Set the suspend bit and clear the PCI bit of this buffer. */
595 channel->ccws[index].flags |= CCW_FLAG_SUSPEND;
596 channel->ccws[index].flags &= ~CCW_FLAG_PCI;
597 /* Check the suspend bit of the previous buffer. */
598 if (channel->iob[prev].state == BUF_STATE_READY) {
600 * Previous buffer is in state ready. It might have
601 * happened in lcs_ready_buffer that the suspend bit
602 * has not been cleared to avoid an endless loop.
605 __lcs_ready_buffer_bits(channel, prev);
607 /* Clear PCI bit of next buffer. */
608 channel->ccws[next].flags &= ~CCW_FLAG_PCI;
609 return __lcs_resume_channel(channel);
613 * Put a processed buffer back to state empty.
616 lcs_release_buffer(struct lcs_channel *channel, struct lcs_buffer *buffer)
620 LCS_DBF_TEXT(5, trace, "relbuff");
621 if (buffer->state != BUF_STATE_LOCKED &&
622 buffer->state != BUF_STATE_PROCESSED)
624 spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
625 buffer->state = BUF_STATE_EMPTY;
626 spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
630 * Get buffer for a lan command.
632 static struct lcs_buffer *
633 lcs_get_lancmd(struct lcs_card *card, int count)
635 struct lcs_buffer *buffer;
638 LCS_DBF_TEXT(4, trace, "getlncmd");
639 /* Get buffer and wait if none is available. */
640 wait_event(card->write.wait_q,
641 ((buffer = lcs_get_buffer(&card->write)) != NULL));
642 count += sizeof(struct lcs_header);
643 *(__u16 *)(buffer->data + count) = 0;
644 buffer->count = count + sizeof(__u16);
645 buffer->callback = lcs_release_buffer;
646 cmd = (struct lcs_cmd *) buffer->data;
648 cmd->type = LCS_FRAME_TYPE_CONTROL;
654 * Notifier function for lancmd replies. Called from read irq.
657 lcs_notify_lancmd_waiters(struct lcs_card *card, struct lcs_cmd *cmd)
659 struct list_head *l, *n;
660 struct lcs_reply *reply;
662 LCS_DBF_TEXT(4, trace, "notiwait");
663 spin_lock(&card->lock);
664 list_for_each_safe(l, n, &card->lancmd_waiters) {
665 reply = list_entry(l, struct lcs_reply, list);
666 if (reply->sequence_no == cmd->sequence_no) {
667 list_del(&reply->list);
668 if (reply->callback != NULL)
669 reply->callback(card, cmd);
671 reply->rc = cmd->return_code;
672 wake_up(&reply->wait_q);
676 spin_unlock(&card->lock);
680 * Emit buffer of a lan comand.
683 lcs_lancmd_timeout(unsigned long data)
685 struct lcs_reply *reply;
687 LCS_DBF_TEXT(4, trace, "timeout");
688 reply = (struct lcs_reply *) data;
689 list_del(&reply->list);
692 wake_up(&reply->wait_q);
696 lcs_send_lancmd(struct lcs_card *card, struct lcs_buffer *buffer,
697 void (*reply_callback)(struct lcs_card *, struct lcs_cmd *))
699 struct lcs_reply reply;
701 struct timer_list timer;
704 LCS_DBF_TEXT(4, trace, "sendcmd");
705 cmd = (struct lcs_cmd *) buffer->data;
706 cmd->sequence_no = ++card->sequence_no;
707 cmd->return_code = 0;
708 reply.sequence_no = cmd->sequence_no;
709 reply.callback = reply_callback;
712 init_waitqueue_head(&reply.wait_q);
713 spin_lock(&card->lock);
714 list_add_tail(&reply.list, &card->lancmd_waiters);
715 spin_unlock(&card->lock);
716 buffer->callback = lcs_release_buffer;
717 rc = lcs_ready_buffer(&card->write, buffer);
721 timer.function = lcs_lancmd_timeout;
722 timer.data = (unsigned long) &reply;
723 timer.expires = jiffies + HZ*card->lancmd_timeout;
725 wait_event(reply.wait_q, reply.received);
727 LCS_DBF_TEXT_(4, trace, "rc:%d",reply.rc);
728 return reply.rc ? -EIO : 0;
732 * LCS startup command
735 lcs_send_startup(struct lcs_card *card, __u8 initiator)
737 struct lcs_buffer *buffer;
740 LCS_DBF_TEXT(2, trace, "startup");
741 buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
742 cmd = (struct lcs_cmd *) buffer->data;
743 cmd->cmd_code = LCS_CMD_STARTUP;
744 cmd->initiator = initiator;
745 cmd->cmd.lcs_startup.buff_size = LCS_IOBUFFERSIZE;
746 return lcs_send_lancmd(card, buffer, NULL);
750 * LCS shutdown command
753 lcs_send_shutdown(struct lcs_card *card)
755 struct lcs_buffer *buffer;
758 LCS_DBF_TEXT(2, trace, "shutdown");
759 buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
760 cmd = (struct lcs_cmd *) buffer->data;
761 cmd->cmd_code = LCS_CMD_SHUTDOWN;
762 cmd->initiator = LCS_INITIATOR_TCPIP;
763 return lcs_send_lancmd(card, buffer, NULL);
767 * LCS lanstat command
770 __lcs_lanstat_cb(struct lcs_card *card, struct lcs_cmd *cmd)
772 LCS_DBF_TEXT(2, trace, "statcb");
773 memcpy(card->mac, cmd->cmd.lcs_lanstat_cmd.mac_addr, LCS_MAC_LENGTH);
777 lcs_send_lanstat(struct lcs_card *card)
779 struct lcs_buffer *buffer;
782 LCS_DBF_TEXT(2,trace, "cmdstat");
783 buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
784 cmd = (struct lcs_cmd *) buffer->data;
785 /* Setup lanstat command. */
786 cmd->cmd_code = LCS_CMD_LANSTAT;
787 cmd->initiator = LCS_INITIATOR_TCPIP;
788 cmd->cmd.lcs_std_cmd.lan_type = card->lan_type;
789 cmd->cmd.lcs_std_cmd.portno = card->portno;
790 return lcs_send_lancmd(card, buffer, __lcs_lanstat_cb);
794 * send stoplan command
797 lcs_send_stoplan(struct lcs_card *card, __u8 initiator)
799 struct lcs_buffer *buffer;
802 LCS_DBF_TEXT(2, trace, "cmdstpln");
803 buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
804 cmd = (struct lcs_cmd *) buffer->data;
805 cmd->cmd_code = LCS_CMD_STOPLAN;
806 cmd->initiator = initiator;
807 cmd->cmd.lcs_std_cmd.lan_type = card->lan_type;
808 cmd->cmd.lcs_std_cmd.portno = card->portno;
809 return lcs_send_lancmd(card, buffer, NULL);
813 * send startlan command
816 __lcs_send_startlan_cb(struct lcs_card *card, struct lcs_cmd *cmd)
818 LCS_DBF_TEXT(2, trace, "srtlancb");
819 card->lan_type = cmd->cmd.lcs_std_cmd.lan_type;
820 card->portno = cmd->cmd.lcs_std_cmd.portno;
824 lcs_send_startlan(struct lcs_card *card, __u8 initiator)
826 struct lcs_buffer *buffer;
829 LCS_DBF_TEXT(2, trace, "cmdstaln");
830 buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
831 cmd = (struct lcs_cmd *) buffer->data;
832 cmd->cmd_code = LCS_CMD_STARTLAN;
833 cmd->initiator = initiator;
834 cmd->cmd.lcs_std_cmd.lan_type = card->lan_type;
835 cmd->cmd.lcs_std_cmd.portno = card->portno;
836 return lcs_send_lancmd(card, buffer, __lcs_send_startlan_cb);
839 #ifdef CONFIG_IP_MULTICAST
841 * send setipm command (Multicast)
844 lcs_send_setipm(struct lcs_card *card,struct lcs_ipm_list *ipm_list)
846 struct lcs_buffer *buffer;
849 LCS_DBF_TEXT(2, trace, "cmdsetim");
850 buffer = lcs_get_lancmd(card, LCS_MULTICAST_CMD_SIZE);
851 cmd = (struct lcs_cmd *) buffer->data;
852 cmd->cmd_code = LCS_CMD_SETIPM;
853 cmd->initiator = LCS_INITIATOR_TCPIP;
854 cmd->cmd.lcs_qipassist.lan_type = card->lan_type;
855 cmd->cmd.lcs_qipassist.portno = card->portno;
856 cmd->cmd.lcs_qipassist.version = 4;
857 cmd->cmd.lcs_qipassist.num_ip_pairs = 1;
858 memcpy(cmd->cmd.lcs_qipassist.lcs_ipass_ctlmsg.ip_mac_pair,
859 &ipm_list->ipm, sizeof (struct lcs_ip_mac_pair));
860 LCS_DBF_TEXT_(2, trace, "%x",ipm_list->ipm.ip_addr);
861 return lcs_send_lancmd(card, buffer, NULL);
865 * send delipm command (Multicast)
868 lcs_send_delipm(struct lcs_card *card,struct lcs_ipm_list *ipm_list)
870 struct lcs_buffer *buffer;
873 LCS_DBF_TEXT(2, trace, "cmddelim");
874 buffer = lcs_get_lancmd(card, LCS_MULTICAST_CMD_SIZE);
875 cmd = (struct lcs_cmd *) buffer->data;
876 cmd->cmd_code = LCS_CMD_DELIPM;
877 cmd->initiator = LCS_INITIATOR_TCPIP;
878 cmd->cmd.lcs_qipassist.lan_type = card->lan_type;
879 cmd->cmd.lcs_qipassist.portno = card->portno;
880 cmd->cmd.lcs_qipassist.version = 4;
881 cmd->cmd.lcs_qipassist.num_ip_pairs = 1;
882 memcpy(cmd->cmd.lcs_qipassist.lcs_ipass_ctlmsg.ip_mac_pair,
883 &ipm_list->ipm, sizeof (struct lcs_ip_mac_pair));
884 LCS_DBF_TEXT_(2, trace, "%x",ipm_list->ipm.ip_addr);
885 return lcs_send_lancmd(card, buffer, NULL);
889 * check if multicast is supported by LCS
892 __lcs_check_multicast_cb(struct lcs_card *card, struct lcs_cmd *cmd)
894 LCS_DBF_TEXT(2, trace, "chkmccb");
895 card->ip_assists_supported =
896 cmd->cmd.lcs_qipassist.ip_assists_supported;
897 card->ip_assists_enabled =
898 cmd->cmd.lcs_qipassist.ip_assists_enabled;
902 lcs_check_multicast_support(struct lcs_card *card)
904 struct lcs_buffer *buffer;
908 LCS_DBF_TEXT(2, trace, "cmdqipa");
909 /* Send query ipassist. */
910 buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
911 cmd = (struct lcs_cmd *) buffer->data;
912 cmd->cmd_code = LCS_CMD_QIPASSIST;
913 cmd->initiator = LCS_INITIATOR_TCPIP;
914 cmd->cmd.lcs_qipassist.lan_type = card->lan_type;
915 cmd->cmd.lcs_qipassist.portno = card->portno;
916 cmd->cmd.lcs_qipassist.version = 4;
917 cmd->cmd.lcs_qipassist.num_ip_pairs = 1;
918 rc = lcs_send_lancmd(card, buffer, __lcs_check_multicast_cb);
920 PRINT_ERR("Query IPAssist failed. Assuming unsupported!\n");
923 /* Print out supported assists: IPv6 */
924 PRINT_INFO("LCS device %s %s IPv6 support\n", card->dev->name,
925 (card->ip_assists_supported & LCS_IPASS_IPV6_SUPPORT) ?
927 /* Print out supported assist: Multicast */
928 PRINT_INFO("LCS device %s %s Multicast support\n", card->dev->name,
929 (card->ip_assists_supported & LCS_IPASS_MULTICAST_SUPPORT) ?
931 if (card->ip_assists_supported & LCS_IPASS_MULTICAST_SUPPORT)
937 * set or del multicast address on LCS card
940 lcs_fix_multicast_list(struct lcs_card *card)
942 struct list_head *l, *n;
943 struct lcs_ipm_list *ipm;
945 LCS_DBF_TEXT(4,trace, "fixipm");
946 spin_lock(&card->ipm_lock);
947 list_for_each_safe(l, n, &card->ipm_list) {
948 ipm = list_entry(l, struct lcs_ipm_list, list);
949 switch (ipm->ipm_state) {
950 case LCS_IPM_STATE_SET_REQUIRED:
951 if (lcs_send_setipm(card, ipm))
952 PRINT_INFO("Adding multicast address failed."
953 "Table possibly full!\n");
955 ipm->ipm_state = LCS_IPM_STATE_ON_CARD;
957 case LCS_IPM_STATE_DEL_REQUIRED:
958 lcs_send_delipm(card, ipm);
959 list_del(&ipm->list);
962 case LCS_IPM_STATE_ON_CARD:
966 if (card->state == DEV_STATE_UP)
967 netif_wake_queue(card->dev);
968 spin_unlock(&card->ipm_lock);
972 * get mac address for the relevant Multicast address
975 lcs_get_mac_for_ipm(__u32 ipm, char *mac, struct net_device *dev)
977 LCS_DBF_TEXT(4,trace, "getmac");
978 if (dev->type == ARPHRD_IEEE802_TR)
979 ip_tr_mc_map(ipm, mac);
981 ip_eth_mc_map(ipm, mac);
985 * function called by net device to handle multicast address relevant things
988 lcs_register_mc_addresses(void *data)
990 struct lcs_card *card;
991 char buf[MAX_ADDR_LEN];
993 struct ip_mc_list *im4;
994 struct in_device *in4_dev;
995 struct lcs_ipm_list *ipm, *tmp;
998 LCS_DBF_TEXT(4, trace, "regmulti");
1000 card = (struct lcs_card *) data;
1001 in4_dev = in_dev_get(card->dev);
1002 if (in4_dev == NULL)
1004 read_lock(&in4_dev->lock);
1005 spin_lock(&card->ipm_lock);
1006 /* Check for multicast addresses to be removed. */
1007 list_for_each(l, &card->ipm_list) {
1008 ipm = list_entry(l, struct lcs_ipm_list, list);
1009 for (im4 = in4_dev->mc_list; im4 != NULL; im4 = im4->next) {
1010 lcs_get_mac_for_ipm(im4->multiaddr, buf, card->dev);
1011 if (memcmp(buf, &ipm->ipm.mac_addr,
1012 LCS_MAC_LENGTH) == 0 &&
1013 ipm->ipm.ip_addr == im4->multiaddr)
1017 ipm->ipm_state = LCS_IPM_STATE_DEL_REQUIRED;
1019 /* Check for multicast addresses to be added. */
1020 for (im4 = in4_dev->mc_list; im4; im4 = im4->next) {
1021 lcs_get_mac_for_ipm(im4->multiaddr, buf, card->dev);
1023 list_for_each(l, &card->ipm_list) {
1024 tmp = list_entry(l, struct lcs_ipm_list, list);
1025 if (memcmp(buf, &tmp->ipm.mac_addr,
1026 LCS_MAC_LENGTH) == 0 &&
1027 tmp->ipm.ip_addr == im4->multiaddr) {
1033 continue; /* Address already in list. */
1034 ipm = (struct lcs_ipm_list *)
1035 kmalloc(sizeof(struct lcs_ipm_list), GFP_ATOMIC);
1037 PRINT_INFO("Not enough memory to add "
1038 "new multicast entry!\n");
1041 memset(ipm, 0, sizeof(struct lcs_ipm_list));
1042 memcpy(&ipm->ipm.mac_addr, buf, LCS_MAC_LENGTH);
1043 ipm->ipm.ip_addr = im4->multiaddr;
1044 ipm->ipm_state = LCS_IPM_STATE_SET_REQUIRED;
1045 list_add(&ipm->list, &card->ipm_list);
1047 spin_unlock(&card->ipm_lock);
1048 read_unlock(&in4_dev->lock);
1049 lcs_fix_multicast_list(card);
1050 in_dev_put(in4_dev);
1054 * function called by net device to
1055 * handle multicast address relevant things
1058 lcs_set_multicast_list(struct net_device *dev)
1060 struct lcs_card *card;
1062 LCS_DBF_TEXT(4, trace, "setmulti");
1063 card = (struct lcs_card *) dev->priv;
1064 set_bit(3, &card->thread_mask);
1065 schedule_work(&card->kernel_thread_starter);
1068 #endif /* CONFIG_IP_MULTICAST */
1071 lcs_check_irb_error(struct ccw_device *cdev, struct irb *irb)
1076 switch (PTR_ERR(irb)) {
1078 PRINT_WARN("i/o-error on device %s\n", cdev->dev.bus_id);
1079 LCS_DBF_TEXT(2, trace, "ckirberr");
1080 LCS_DBF_TEXT_(2, trace, " rc%d", -EIO);
1083 PRINT_WARN("timeout on device %s\n", cdev->dev.bus_id);
1084 LCS_DBF_TEXT(2, trace, "ckirberr");
1085 LCS_DBF_TEXT_(2, trace, " rc%d", -ETIMEDOUT);
1088 PRINT_WARN("unknown error %ld on device %s\n", PTR_ERR(irb),
1090 LCS_DBF_TEXT(2, trace, "ckirberr");
1091 LCS_DBF_TEXT(2, trace, " rc???");
1093 return PTR_ERR(irb);
1098 * IRQ Handler for LCS channels
1101 lcs_irq(struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
1103 struct lcs_card *card;
1104 struct lcs_channel *channel;
1107 if (lcs_check_irb_error(cdev, irb))
1110 card = CARD_FROM_DEV(cdev);
1111 if (card->read.ccwdev == cdev)
1112 channel = &card->read;
1114 channel = &card->write;
1116 LCS_DBF_TEXT_(5, trace, "Rint%s",cdev->dev.bus_id);
1117 LCS_DBF_TEXT_(5, trace, "%4x%4x",irb->scsw.cstat, irb->scsw.dstat);
1119 /* How far in the ccw chain have we processed? */
1120 if ((channel->state != CH_STATE_INIT) &&
1121 (irb->scsw.fctl & SCSW_FCTL_START_FUNC)) {
1122 index = (struct ccw1 *) __va((addr_t) irb->scsw.cpa)
1124 if ((irb->scsw.actl & SCSW_ACTL_SUSPENDED) ||
1125 (irb->scsw.cstat | SCHN_STAT_PCI))
1126 /* Bloody io subsystem tells us lies about cpa... */
1127 index = (index - 1) & (LCS_NUM_BUFFS - 1);
1128 while (channel->io_idx != index) {
1129 __lcs_processed_buffer(channel,
1130 channel->iob + channel->io_idx);
1132 (channel->io_idx + 1) & (LCS_NUM_BUFFS - 1);
1136 if ((irb->scsw.dstat & DEV_STAT_DEV_END) ||
1137 (irb->scsw.dstat & DEV_STAT_CHN_END) ||
1138 (irb->scsw.dstat & DEV_STAT_UNIT_CHECK))
1139 /* Mark channel as stopped. */
1140 channel->state = CH_STATE_STOPPED;
1141 else if (irb->scsw.actl & SCSW_ACTL_SUSPENDED)
1142 /* CCW execution stopped on a suspend bit. */
1143 channel->state = CH_STATE_SUSPENDED;
1145 if (irb->scsw.fctl & SCSW_FCTL_HALT_FUNC) {
1146 if (irb->scsw.cc != 0) {
1147 ccw_device_halt(channel->ccwdev, (addr_t) channel);
1150 /* The channel has been stopped by halt_IO. */
1151 channel->state = CH_STATE_HALTED;
1154 if (irb->scsw.fctl & SCSW_FCTL_CLEAR_FUNC) {
1155 channel->state = CH_STATE_CLEARED;
1157 /* Do the rest in the tasklet. */
1158 tasklet_schedule(&channel->irq_tasklet);
1162 * Tasklet for IRQ handler
1165 lcs_tasklet(unsigned long data)
1167 unsigned long flags;
1168 struct lcs_channel *channel;
1169 struct lcs_buffer *iob;
1173 channel = (struct lcs_channel *) data;
1174 LCS_DBF_TEXT_(5, trace, "tlet%s",channel->ccwdev->dev.bus_id);
1176 /* Check for processed buffers. */
1178 buf_idx = channel->buf_idx;
1179 while (iob[buf_idx].state == BUF_STATE_PROCESSED) {
1180 /* Do the callback thing. */
1181 if (iob[buf_idx].callback != NULL)
1182 iob[buf_idx].callback(channel, iob + buf_idx);
1183 buf_idx = (buf_idx + 1) & (LCS_NUM_BUFFS - 1);
1185 channel->buf_idx = buf_idx;
1187 if (channel->state == CH_STATE_STOPPED)
1188 // FIXME: what if rc != 0 ??
1189 rc = lcs_start_channel(channel);
1190 spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
1191 if (channel->state == CH_STATE_SUSPENDED &&
1192 channel->iob[channel->io_idx].state == BUF_STATE_READY) {
1193 // FIXME: what if rc != 0 ??
1194 rc = __lcs_resume_channel(channel);
1196 spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
1198 /* Something happened on the channel. Wake up waiters. */
1199 wake_up(&channel->wait_q);
1203 * Finish current tx buffer and make it ready for transmit.
1206 __lcs_emit_txbuffer(struct lcs_card *card)
1208 LCS_DBF_TEXT(5, trace, "emittx");
1209 *(__u16 *)(card->tx_buffer->data + card->tx_buffer->count) = 0;
1210 card->tx_buffer->count += 2;
1211 lcs_ready_buffer(&card->write, card->tx_buffer);
1212 card->tx_buffer = NULL;
1217 * Callback for finished tx buffers.
1220 lcs_txbuffer_cb(struct lcs_channel *channel, struct lcs_buffer *buffer)
1222 struct lcs_card *card;
1224 LCS_DBF_TEXT(5, trace, "txbuffcb");
1225 /* Put buffer back to pool. */
1226 lcs_release_buffer(channel, buffer);
1227 card = (struct lcs_card *)
1228 ((char *) channel - offsetof(struct lcs_card, write));
1229 spin_lock(&card->lock);
1231 if (card->tx_emitted <= 0 && card->tx_buffer != NULL)
1233 * Last running tx buffer has finished. Submit partially
1234 * filled current buffer.
1236 __lcs_emit_txbuffer(card);
1237 spin_unlock(&card->lock);
1241 * Packet transmit function called by network stack
1244 __lcs_start_xmit(struct lcs_card *card, struct sk_buff *skb,
1245 struct net_device *dev)
1247 struct lcs_header *header;
1249 LCS_DBF_TEXT(5, trace, "hardxmit");
1251 card->stats.tx_dropped++;
1252 card->stats.tx_errors++;
1255 if (card->state != DEV_STATE_UP) {
1257 card->stats.tx_dropped++;
1258 card->stats.tx_errors++;
1259 card->stats.tx_carrier_errors++;
1262 if (netif_queue_stopped(dev) ) {
1263 card->stats.tx_dropped++;
1266 if (card->tx_buffer != NULL &&
1267 card->tx_buffer->count + sizeof(struct lcs_header) +
1268 skb->len + sizeof(u16) > LCS_IOBUFFERSIZE)
1269 /* skb too big for current tx buffer. */
1270 __lcs_emit_txbuffer(card);
1271 if (card->tx_buffer == NULL) {
1272 /* Get new tx buffer */
1273 card->tx_buffer = lcs_get_buffer(&card->write);
1274 if (card->tx_buffer == NULL) {
1275 card->stats.tx_dropped++;
1278 card->tx_buffer->callback = lcs_txbuffer_cb;
1279 card->tx_buffer->count = 0;
1281 header = (struct lcs_header *)
1282 (card->tx_buffer->data + card->tx_buffer->count);
1283 card->tx_buffer->count += skb->len + sizeof(struct lcs_header);
1284 header->offset = card->tx_buffer->count;
1285 header->type = card->lan_type;
1286 header->slot = card->portno;
1287 memcpy(header + 1, skb->data, skb->len);
1288 card->stats.tx_bytes += skb->len;
1289 card->stats.tx_packets++;
1291 if (card->tx_emitted <= 0)
1292 /* If this is the first tx buffer emit it immediately. */
1293 __lcs_emit_txbuffer(card);
1298 lcs_start_xmit(struct sk_buff *skb, struct net_device *dev)
1300 struct lcs_card *card;
1303 LCS_DBF_TEXT(5, trace, "pktxmit");
1304 card = (struct lcs_card *) dev->priv;
1305 spin_lock(&card->lock);
1306 rc = __lcs_start_xmit(card, skb, dev);
1307 spin_unlock(&card->lock);
1312 * send startlan and lanstat command to make LCS device ready
1315 lcs_startlan_auto(struct lcs_card *card)
1319 LCS_DBF_TEXT(2, trace, "strtauto");
1320 #ifdef CONFIG_NET_ETHERNET
1321 card->lan_type = LCS_FRAME_TYPE_ENET;
1322 rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP);
1328 card->lan_type = LCS_FRAME_TYPE_TR;
1329 rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP);
1334 card->lan_type = LCS_FRAME_TYPE_FDDI;
1335 rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP);
1343 lcs_startlan(struct lcs_card *card)
1347 LCS_DBF_TEXT(2, trace, "startlan");
1349 if (card->portno != LCS_INVALID_PORT_NO) {
1350 if (card->lan_type == LCS_FRAME_TYPE_AUTO)
1351 rc = lcs_startlan_auto(card);
1353 rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP);
1355 for (i = 0; i <= 16; i++) {
1357 if (card->lan_type != LCS_FRAME_TYPE_AUTO)
1358 rc = lcs_send_startlan(card,
1359 LCS_INITIATOR_TCPIP);
1361 /* autodetecting lan type */
1362 rc = lcs_startlan_auto(card);
1368 return lcs_send_lanstat(card);
1373 * LCS detect function
1374 * setup channels and make them I/O ready
1377 lcs_detect(struct lcs_card *card)
1381 LCS_DBF_TEXT(2, setup, "lcsdetct");
1382 /* start/reset card */
1384 netif_stop_queue(card->dev);
1385 card->write.state = CH_STATE_INIT;
1386 card->read.state = CH_STATE_INIT;
1387 rc = lcs_stop_channels(card);
1389 rc = lcs_start_channels(card);
1391 rc = lcs_send_startup(card, LCS_INITIATOR_TCPIP);
1393 rc = lcs_startlan(card);
1397 card->state = DEV_STATE_UP;
1399 card->state = DEV_STATE_DOWN;
1400 card->write.state = CH_STATE_INIT;
1401 card->read.state = CH_STATE_INIT;
1410 lcs_resetcard(struct lcs_card *card)
1414 LCS_DBF_TEXT(2, trace, "rescard");
1415 for (retries = 0; retries < 10; retries++) {
1416 if (lcs_detect(card) == 0) {
1417 netif_wake_queue(card->dev);
1418 card->state = DEV_STATE_UP;
1419 PRINT_INFO("LCS device %s successfully restarted!\n",
1423 schedule_timeout(3 * HZ);
1425 PRINT_ERR("Error in Reseting LCS card!\n");
1433 lcs_stopcard(struct lcs_card *card)
1437 LCS_DBF_TEXT(3, setup, "stopcard");
1439 if (card->read.state != CH_STATE_STOPPED &&
1440 card->write.state != CH_STATE_STOPPED &&
1441 card->state == DEV_STATE_UP) {
1442 rc = lcs_send_stoplan(card,LCS_INITIATOR_TCPIP);
1443 rc = lcs_send_shutdown(card);
1445 rc = lcs_stop_channels(card);
1446 card->state = DEV_STATE_DOWN;
1452 * LGW initiated commands
1455 lcs_lgw_startlan_thread(void *data)
1457 struct lcs_card *card;
1459 card = (struct lcs_card *) data;
1460 daemonize("lgwstpln");
1461 LCS_DBF_TEXT(4, trace, "lgwstpln");
1463 netif_stop_queue(card->dev);
1464 if (lcs_startlan(card) == 0) {
1465 netif_wake_queue(card->dev);
1466 card->state = DEV_STATE_UP;
1467 PRINT_INFO("LCS Startlan for device %s succeeded!\n",
1471 PRINT_ERR("LCS Startlan for device %s failed!\n",
1477 * Send startup command initiated by Lan Gateway
1480 lcs_lgw_startup_thread(void *data)
1484 struct lcs_card *card;
1486 card = (struct lcs_card *) data;
1487 daemonize("lgwstpln");
1488 LCS_DBF_TEXT(4, trace, "lgwstpln");
1490 netif_stop_queue(card->dev);
1491 rc = lcs_send_startup(card, LCS_INITIATOR_LGW);
1493 PRINT_ERR("Startup for LCS device %s initiated " \
1494 "by LGW failed!\nReseting card ...\n",
1496 /* do a card reset */
1497 rc = lcs_resetcard(card);
1501 rc = lcs_startlan(card);
1503 netif_wake_queue(card->dev);
1504 card->state = DEV_STATE_UP;
1508 PRINT_INFO("LCS Startup for device %s succeeded!\n",
1511 PRINT_ERR("LCS Startup for device %s failed!\n",
1518 * send stoplan command initiated by Lan Gateway
1521 lcs_lgw_stoplan_thread(void *data)
1523 struct lcs_card *card;
1526 card = (struct lcs_card *) data;
1527 daemonize("lgwstop");
1528 LCS_DBF_TEXT(4, trace, "lgwstop");
1530 netif_stop_queue(card->dev);
1531 if (lcs_send_stoplan(card, LCS_INITIATOR_LGW) == 0)
1532 PRINT_INFO("Stoplan for %s initiated by LGW succeeded!\n",
1535 PRINT_ERR("Stoplan %s initiated by LGW failed!\n",
1537 /*Try to reset the card, stop it on failure */
1538 rc = lcs_resetcard(card);
1540 rc = lcs_stopcard(card);
1545 * Kernel Thread helper functions for LGW initiated commands
1548 lcs_start_kernel_thread(struct lcs_card *card)
1550 LCS_DBF_TEXT(5, trace, "krnthrd");
1551 if (test_and_clear_bit(0, &card->thread_mask))
1552 kernel_thread(lcs_lgw_startup_thread, (void *) card, SIGCHLD);
1553 if (test_and_clear_bit(1, &card->thread_mask))
1554 kernel_thread(lcs_lgw_startlan_thread, (void *) card, SIGCHLD);
1555 if (test_and_clear_bit(2, &card->thread_mask))
1556 kernel_thread(lcs_lgw_stoplan_thread, (void *) card, SIGCHLD);
1557 #ifdef CONFIG_IP_MULTICAST
1558 if (test_and_clear_bit(3, &card->thread_mask))
1559 kernel_thread(lcs_register_mc_addresses, (void *) card, SIGCHLD);
1564 * Process control frames.
1567 lcs_get_control(struct lcs_card *card, struct lcs_cmd *cmd)
1569 LCS_DBF_TEXT(5, trace, "getctrl");
1570 if (cmd->initiator == LCS_INITIATOR_LGW) {
1571 switch(cmd->cmd_code) {
1572 case LCS_CMD_STARTUP:
1573 set_bit(0, &card->thread_mask);
1574 schedule_work(&card->kernel_thread_starter);
1576 case LCS_CMD_STARTLAN:
1577 set_bit(1, &card->thread_mask);
1578 schedule_work(&card->kernel_thread_starter);
1580 case LCS_CMD_STOPLAN:
1581 set_bit(2, &card->thread_mask);
1582 schedule_work(&card->kernel_thread_starter);
1585 PRINT_INFO("UNRECOGNIZED LGW COMMAND\n");
1589 lcs_notify_lancmd_waiters(card, cmd);
1593 * Unpack network packet.
1596 lcs_get_skb(struct lcs_card *card, char *skb_data, unsigned int skb_len)
1598 struct sk_buff *skb;
1600 LCS_DBF_TEXT(5, trace, "getskb");
1601 if (card->dev == NULL ||
1602 card->state != DEV_STATE_UP)
1603 /* The card isn't up. Ignore the packet. */
1606 skb = dev_alloc_skb(skb_len);
1608 PRINT_ERR("LCS: alloc_skb failed for device=%s\n",
1610 card->stats.rx_dropped++;
1613 skb->dev = card->dev;
1614 memcpy(skb_put(skb, skb_len), skb_data, skb_len);
1615 skb->protocol = card->lan_type_trans(skb, card->dev);
1616 card->stats.rx_bytes += skb_len;
1617 card->stats.rx_packets++;
1622 * LCS main routine to get packets and lancmd replies from the buffers
1625 lcs_get_frames_cb(struct lcs_channel *channel, struct lcs_buffer *buffer)
1627 struct lcs_card *card;
1628 struct lcs_header *lcs_hdr;
1631 LCS_DBF_TEXT(5, trace, "lcsgtpkt");
1632 lcs_hdr = (struct lcs_header *) buffer->data;
1633 if (lcs_hdr->offset == LCS_ILLEGAL_OFFSET) {
1634 LCS_DBF_TEXT(4, trace, "-eiogpkt");
1637 card = (struct lcs_card *)
1638 ((char *) channel - offsetof(struct lcs_card, read));
1640 while (lcs_hdr->offset != 0) {
1641 if (lcs_hdr->offset <= 0 ||
1642 lcs_hdr->offset > LCS_IOBUFFERSIZE ||
1643 lcs_hdr->offset < offset) {
1644 /* Offset invalid. */
1645 card->stats.rx_length_errors++;
1646 card->stats.rx_errors++;
1649 /* What kind of frame is it? */
1650 if (lcs_hdr->type == LCS_FRAME_TYPE_CONTROL)
1651 /* Control frame. */
1652 lcs_get_control(card, (struct lcs_cmd *) lcs_hdr);
1653 else if (lcs_hdr->type == LCS_FRAME_TYPE_ENET ||
1654 lcs_hdr->type == LCS_FRAME_TYPE_TR ||
1655 lcs_hdr->type == LCS_FRAME_TYPE_FDDI)
1656 /* Normal network packet. */
1657 lcs_get_skb(card, (char *)(lcs_hdr + 1),
1658 lcs_hdr->offset - offset -
1659 sizeof(struct lcs_header));
1661 /* Unknown frame type. */
1662 ; // FIXME: error message ?
1663 /* Proceed to next frame. */
1664 offset = lcs_hdr->offset;
1665 lcs_hdr->offset = LCS_ILLEGAL_OFFSET;
1666 lcs_hdr = (struct lcs_header *) (buffer->data + offset);
1668 /* The buffer is now empty. Make it ready again. */
1669 lcs_ready_buffer(&card->read, buffer);
1673 * get network statistics for ifconfig and other user programs
1675 static struct net_device_stats *
1676 lcs_getstats(struct net_device *dev)
1678 struct lcs_card *card;
1680 LCS_DBF_TEXT(4, trace, "netstats");
1681 card = (struct lcs_card *) dev->priv;
1682 return &card->stats;
1687 * This function will be called by user doing ifconfig xxx down
1690 lcs_stop_device(struct net_device *dev)
1692 struct lcs_card *card;
1695 LCS_DBF_TEXT(2, trace, "stopdev");
1696 card = (struct lcs_card *) dev->priv;
1697 netif_stop_queue(dev);
1698 dev->flags &= ~IFF_UP;
1699 rc = lcs_stopcard(card);
1701 PRINT_ERR("Try it again!\n ");
1706 * start lcs device and make it runnable
1707 * This function will be called by user doing ifconfig xxx up
1710 lcs_open_device(struct net_device *dev)
1712 struct lcs_card *card;
1715 LCS_DBF_TEXT(2, trace, "opendev");
1716 card = (struct lcs_card *) dev->priv;
1717 /* initialize statistics */
1718 rc = lcs_detect(card);
1720 PRINT_ERR("LCS:Error in opening device!\n");
1723 dev->flags |= IFF_UP;
1724 netif_wake_queue(dev);
1725 card->state = DEV_STATE_UP;
1731 * show function for portno called by cat or similar things
1734 lcs_portno_show (struct device *dev, char *buf)
1736 struct lcs_card *card;
1738 card = (struct lcs_card *)dev->driver_data;
1743 return sprintf(buf, "%d\n", card->portno);
1747 * store the value which is piped to file portno
1750 lcs_portno_store (struct device *dev, const char *buf, size_t count)
1752 struct lcs_card *card;
1755 card = (struct lcs_card *)dev->driver_data;
1760 sscanf(buf, "%u", &value);
1761 /* TODO: sanity checks */
1762 card->portno = value;
1768 static DEVICE_ATTR(portno, 0644, lcs_portno_show, lcs_portno_store);
1771 lcs_type_show(struct device *dev, char *buf)
1773 struct ccwgroup_device *cgdev;
1775 cgdev = to_ccwgroupdev(dev);
1779 return sprintf(buf, "%s\n", cu3088_type[cgdev->cdev[0]->id.driver_info]);
1782 static DEVICE_ATTR(type, 0444, lcs_type_show, NULL);
1785 lcs_timeout_show(struct device *dev, char *buf)
1787 struct lcs_card *card;
1789 card = (struct lcs_card *)dev->driver_data;
1791 return card ? sprintf(buf, "%u\n", card->lancmd_timeout) : 0;
1795 lcs_timeout_store (struct device *dev, const char *buf, size_t count)
1797 struct lcs_card *card;
1800 card = (struct lcs_card *)dev->driver_data;
1805 sscanf(buf, "%u", &value);
1806 /* TODO: sanity checks */
1807 card->lancmd_timeout = value;
1813 DEVICE_ATTR(lancmd_timeout, 0644, lcs_timeout_show, lcs_timeout_store);
1815 static struct attribute * lcs_attrs[] = {
1816 &dev_attr_portno.attr,
1817 &dev_attr_type.attr,
1818 &dev_attr_lancmd_timeout.attr,
1822 static struct attribute_group lcs_attr_group = {
1827 * lcs_probe_device is called on establishing a new ccwgroup_device.
1830 lcs_probe_device(struct ccwgroup_device *ccwgdev)
1832 struct lcs_card *card;
1835 if (!get_device(&ccwgdev->dev))
1838 LCS_DBF_TEXT(2, setup, "add_dev");
1839 card = lcs_alloc_card();
1841 PRINT_ERR("Allocation of lcs card failed\n");
1842 put_device(&ccwgdev->dev);
1845 ret = sysfs_create_group(&ccwgdev->dev.kobj, &lcs_attr_group);
1847 PRINT_ERR("Creating attributes failed");
1848 lcs_free_card(card);
1849 put_device(&ccwgdev->dev);
1852 ccwgdev->dev.driver_data = card;
1853 ccwgdev->cdev[0]->handler = lcs_irq;
1854 ccwgdev->cdev[1]->handler = lcs_irq;
1859 lcs_register_netdev(struct ccwgroup_device *ccwgdev)
1861 struct lcs_card *card;
1863 LCS_DBF_TEXT(2, setup, "regnetdv");
1864 card = (struct lcs_card *)ccwgdev->dev.driver_data;
1865 if (card->dev->reg_state != NETREG_UNINITIALIZED)
1867 SET_NETDEV_DEV(card->dev, &ccwgdev->dev);
1868 return register_netdev(card->dev);
1872 * lcs_new_device will be called by setting the group device online.
1876 lcs_new_device(struct ccwgroup_device *ccwgdev)
1878 struct lcs_card *card;
1879 struct net_device *dev=NULL;
1880 enum lcs_dev_states recover_state;
1883 card = (struct lcs_card *)ccwgdev->dev.driver_data;
1887 LCS_DBF_TEXT(2, setup, "newdev");
1888 LCS_DBF_HEX(3, setup, &card, sizeof(void*));
1889 card->read.ccwdev = ccwgdev->cdev[0];
1890 card->write.ccwdev = ccwgdev->cdev[1];
1892 recover_state = card->state;
1893 ccw_device_set_online(card->read.ccwdev);
1894 ccw_device_set_online(card->write.ccwdev);
1896 LCS_DBF_TEXT(3, setup, "lcsnewdv");
1898 lcs_setup_card(card);
1899 rc = lcs_detect(card);
1901 LCS_DBF_TEXT(2, setup, "dtctfail");
1902 PRINT_WARN("Detection of LCS card failed with return code "
1903 "%d (0x%x)\n", rc, rc);
1908 LCS_DBF_TEXT(2, setup, "samedev");
1909 LCS_DBF_HEX(3, setup, &card, sizeof(void*));
1912 switch (card->lan_type) {
1913 #ifdef CONFIG_NET_ETHERNET
1914 case LCS_FRAME_TYPE_ENET:
1915 card->lan_type_trans = eth_type_trans;
1916 dev = alloc_etherdev(0);
1920 case LCS_FRAME_TYPE_TR:
1921 card->lan_type_trans = tr_type_trans;
1922 dev = alloc_trdev(0);
1926 case LCS_FRAME_TYPE_FDDI:
1927 card->lan_type_trans = fddi_type_trans;
1928 dev = alloc_fddidev(0);
1932 LCS_DBF_TEXT(3, setup, "errinit");
1933 PRINT_ERR("LCS: Initialization failed\n");
1934 PRINT_ERR("LCS: No device found!\n");
1941 card->dev->priv = card;
1942 card->dev->open = lcs_open_device;
1943 card->dev->stop = lcs_stop_device;
1944 card->dev->hard_start_xmit = lcs_start_xmit;
1945 card->dev->get_stats = lcs_getstats;
1946 SET_MODULE_OWNER(dev);
1947 if (lcs_register_netdev(ccwgdev) != 0)
1949 memcpy(card->dev->dev_addr, card->mac, LCS_MAC_LENGTH);
1950 #ifdef CONFIG_IP_MULTICAST
1951 if (!lcs_check_multicast_support(card))
1952 card->dev->set_multicast_list = lcs_set_multicast_list;
1954 netif_stop_queue(card->dev);
1955 if (recover_state == DEV_STATE_RECOVER) {
1956 card->dev->flags |= IFF_UP;
1957 netif_wake_queue(card->dev);
1958 card->state = DEV_STATE_UP;
1965 ccw_device_set_offline(card->read.ccwdev);
1966 ccw_device_set_offline(card->write.ccwdev);
1971 * lcs_shutdown_device, called when setting the group device offline.
1974 lcs_shutdown_device(struct ccwgroup_device *ccwgdev)
1976 struct lcs_card *card;
1977 enum lcs_dev_states recover_state;
1980 LCS_DBF_TEXT(3, setup, "shtdndev");
1981 card = (struct lcs_card *)ccwgdev->dev.driver_data;
1985 LCS_DBF_HEX(3, setup, &card, sizeof(void*));
1986 recover_state = card->state;
1988 ret = lcs_stop_device(card->dev);
1989 ret = ccw_device_set_offline(card->read.ccwdev);
1990 ret = ccw_device_set_offline(card->write.ccwdev);
1991 if (recover_state == DEV_STATE_UP) {
1992 card->state = DEV_STATE_RECOVER;
2000 * lcs_remove_device, free buffers and card
2003 lcs_remove_device(struct ccwgroup_device *ccwgdev)
2005 struct lcs_card *card;
2007 card = (struct lcs_card *)ccwgdev->dev.driver_data;
2011 PRINT_INFO("Removing lcs group device ....\n");
2012 LCS_DBF_TEXT(3, setup, "remdev");
2013 LCS_DBF_HEX(3, setup, &card, sizeof(void*));
2014 if (ccwgdev->state == CCWGROUP_ONLINE) {
2015 lcs_shutdown_device(ccwgdev);
2018 unregister_netdev(card->dev);
2019 sysfs_remove_group(&ccwgdev->dev.kobj, &lcs_attr_group);
2020 lcs_cleanup_card(card);
2021 lcs_free_card(card);
2022 put_device(&ccwgdev->dev);
2026 * LCS ccwgroup driver registration
2028 static struct ccwgroup_driver lcs_group_driver = {
2029 .owner = THIS_MODULE,
2032 .driver_id = 0xD3C3E2,
2033 .probe = lcs_probe_device,
2034 .remove = lcs_remove_device,
2035 .set_online = lcs_new_device,
2036 .set_offline = lcs_shutdown_device,
2040 * LCS Module/Kernel initialization function
2043 __init lcs_init_module(void)
2047 PRINT_INFO("Loading %s\n",version);
2048 rc = lcs_register_debug_facility();
2049 LCS_DBF_TEXT(0, setup, "lcsinit");
2051 PRINT_ERR("Initialization failed\n");
2055 rc = register_cu3088_discipline(&lcs_group_driver);
2057 PRINT_ERR("Initialization failed\n");
2066 * LCS module cleanup function
2069 __exit lcs_cleanup_module(void)
2071 PRINT_INFO("Terminating lcs module.\n");
2072 LCS_DBF_TEXT(0, trace, "cleanup");
2073 unregister_cu3088_discipline(&lcs_group_driver);
2074 lcs_unregister_debug_facility();
2077 module_init(lcs_init_module);
2078 module_exit(lcs_cleanup_module);
2080 MODULE_AUTHOR("Frank Pavlic <pavlic@de.ibm.com>");
2081 MODULE_LICENSE("GPL");