Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0+
0002 /*
0003  *  Linux for S/390 Lan Channel Station Network Driver
0004  *
0005  *  Copyright IBM Corp. 1999, 2009
0006  *  Author(s): Original Code written by
0007  *          DJ Barrow <djbarrow@de.ibm.com,barrow_dj@yahoo.com>
0008  *         Rewritten by
0009  *          Frank Pavlic <fpavlic@de.ibm.com> and
0010  *          Martin Schwidefsky <schwidefsky@de.ibm.com>
0011  */
0012 
0013 #define KMSG_COMPONENT      "lcs"
0014 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
0015 
0016 #include <linux/module.h>
0017 #include <linux/if.h>
0018 #include <linux/netdevice.h>
0019 #include <linux/etherdevice.h>
0020 #include <linux/fddidevice.h>
0021 #include <linux/inetdevice.h>
0022 #include <linux/in.h>
0023 #include <linux/igmp.h>
0024 #include <linux/delay.h>
0025 #include <linux/kthread.h>
0026 #include <linux/slab.h>
0027 #include <net/arp.h>
0028 #include <net/ip.h>
0029 
0030 #include <asm/debug.h>
0031 #include <asm/idals.h>
0032 #include <asm/timex.h>
0033 #include <linux/device.h>
0034 #include <asm/ccwgroup.h>
0035 
0036 #include "lcs.h"
0037 
0038 
0039 #if !defined(CONFIG_ETHERNET) && !defined(CONFIG_FDDI)
0040 #error Cannot compile lcs.c without some net devices switched on.
0041 #endif
0042 
0043 /*
0044  * initialization string for output
0045  */
0046 
0047 static char version[] __initdata = "LCS driver";
0048 
0049 /*
0050   * the root device for lcs group devices
0051   */
0052 static struct device *lcs_root_dev;
0053 
0054 /*
0055  * Some prototypes.
0056  */
0057 static void lcs_tasklet(unsigned long);
0058 static void lcs_start_kernel_thread(struct work_struct *);
0059 static void lcs_get_frames_cb(struct lcs_channel *, struct lcs_buffer *);
0060 #ifdef CONFIG_IP_MULTICAST
0061 static int lcs_send_delipm(struct lcs_card *, struct lcs_ipm_list *);
0062 #endif /* CONFIG_IP_MULTICAST */
0063 static int lcs_recovery(void *ptr);
0064 
0065 /*
0066  * Debug Facility Stuff
0067  */
0068 static char debug_buffer[255];
0069 static debug_info_t *lcs_dbf_setup;
0070 static debug_info_t *lcs_dbf_trace;
0071 
0072 /*
0073  *  LCS Debug Facility functions
0074  */
0075 static void
0076 lcs_unregister_debug_facility(void)
0077 {
0078     debug_unregister(lcs_dbf_setup);
0079     debug_unregister(lcs_dbf_trace);
0080 }
0081 
0082 static int
0083 lcs_register_debug_facility(void)
0084 {
0085     lcs_dbf_setup = debug_register("lcs_setup", 2, 1, 8);
0086     lcs_dbf_trace = debug_register("lcs_trace", 4, 1, 8);
0087     if (lcs_dbf_setup == NULL || lcs_dbf_trace == NULL) {
0088         pr_err("Not enough memory for debug facility.\n");
0089         lcs_unregister_debug_facility();
0090         return -ENOMEM;
0091     }
0092     debug_register_view(lcs_dbf_setup, &debug_hex_ascii_view);
0093     debug_set_level(lcs_dbf_setup, 2);
0094     debug_register_view(lcs_dbf_trace, &debug_hex_ascii_view);
0095     debug_set_level(lcs_dbf_trace, 2);
0096     return 0;
0097 }
0098 
0099 /*
0100  * Allocate io buffers.
0101  */
0102 static int
0103 lcs_alloc_channel(struct lcs_channel *channel)
0104 {
0105     int cnt;
0106 
0107     LCS_DBF_TEXT(2, setup, "ichalloc");
0108     for (cnt = 0; cnt < LCS_NUM_BUFFS; cnt++) {
0109         /* alloc memory fo iobuffer */
0110         channel->iob[cnt].data =
0111             kzalloc(LCS_IOBUFFERSIZE, GFP_DMA | GFP_KERNEL);
0112         if (channel->iob[cnt].data == NULL)
0113             break;
0114         channel->iob[cnt].state = LCS_BUF_STATE_EMPTY;
0115     }
0116     if (cnt < LCS_NUM_BUFFS) {
0117         /* Not all io buffers could be allocated. */
0118         LCS_DBF_TEXT(2, setup, "echalloc");
0119         while (cnt-- > 0)
0120             kfree(channel->iob[cnt].data);
0121         return -ENOMEM;
0122     }
0123     return 0;
0124 }
0125 
0126 /*
0127  * Free io buffers.
0128  */
0129 static void
0130 lcs_free_channel(struct lcs_channel *channel)
0131 {
0132     int cnt;
0133 
0134     LCS_DBF_TEXT(2, setup, "ichfree");
0135     for (cnt = 0; cnt < LCS_NUM_BUFFS; cnt++) {
0136         kfree(channel->iob[cnt].data);
0137         channel->iob[cnt].data = NULL;
0138     }
0139 }
0140 
0141 /*
0142  * Cleanup channel.
0143  */
0144 static void
0145 lcs_cleanup_channel(struct lcs_channel *channel)
0146 {
0147     LCS_DBF_TEXT(3, setup, "cleanch");
0148     /* Kill write channel tasklets. */
0149     tasklet_kill(&channel->irq_tasklet);
0150     /* Free channel buffers. */
0151     lcs_free_channel(channel);
0152 }
0153 
0154 /*
0155  * LCS free memory for card and channels.
0156  */
0157 static void
0158 lcs_free_card(struct lcs_card *card)
0159 {
0160     LCS_DBF_TEXT(2, setup, "remcard");
0161     LCS_DBF_HEX(2, setup, &card, sizeof(void*));
0162     kfree(card);
0163 }
0164 
0165 /*
0166  * LCS alloc memory for card and channels
0167  */
0168 static struct lcs_card *
0169 lcs_alloc_card(void)
0170 {
0171     struct lcs_card *card;
0172     int rc;
0173 
0174     LCS_DBF_TEXT(2, setup, "alloclcs");
0175 
0176     card = kzalloc(sizeof(struct lcs_card), GFP_KERNEL | GFP_DMA);
0177     if (card == NULL)
0178         return NULL;
0179     card->lan_type = LCS_FRAME_TYPE_AUTO;
0180     card->pkt_seq = 0;
0181     card->lancmd_timeout = LCS_LANCMD_TIMEOUT_DEFAULT;
0182     /* Allocate io buffers for the read channel. */
0183     rc = lcs_alloc_channel(&card->read);
0184     if (rc){
0185         LCS_DBF_TEXT(2, setup, "iccwerr");
0186         lcs_free_card(card);
0187         return NULL;
0188     }
0189     /* Allocate io buffers for the write channel. */
0190     rc = lcs_alloc_channel(&card->write);
0191     if (rc) {
0192         LCS_DBF_TEXT(2, setup, "iccwerr");
0193         lcs_cleanup_channel(&card->read);
0194         lcs_free_card(card);
0195         return NULL;
0196     }
0197 
0198 #ifdef CONFIG_IP_MULTICAST
0199     INIT_LIST_HEAD(&card->ipm_list);
0200 #endif
0201     LCS_DBF_HEX(2, setup, &card, sizeof(void*));
0202     return card;
0203 }
0204 
0205 /*
0206  * Setup read channel.
0207  */
0208 static void
0209 lcs_setup_read_ccws(struct lcs_card *card)
0210 {
0211     int cnt;
0212 
0213     LCS_DBF_TEXT(2, setup, "ireadccw");
0214     /* Setup read ccws. */
0215     memset(card->read.ccws, 0, sizeof (struct ccw1) * (LCS_NUM_BUFFS + 1));
0216     for (cnt = 0; cnt < LCS_NUM_BUFFS; cnt++) {
0217         card->read.ccws[cnt].cmd_code = LCS_CCW_READ;
0218         card->read.ccws[cnt].count = LCS_IOBUFFERSIZE;
0219         card->read.ccws[cnt].flags =
0220             CCW_FLAG_CC | CCW_FLAG_SLI | CCW_FLAG_PCI;
0221         /*
0222          * Note: we have allocated the buffer with GFP_DMA, so
0223          * we do not need to do set_normalized_cda.
0224          */
0225         card->read.ccws[cnt].cda =
0226             (__u32)virt_to_phys(card->read.iob[cnt].data);
0227         ((struct lcs_header *)
0228          card->read.iob[cnt].data)->offset = LCS_ILLEGAL_OFFSET;
0229         card->read.iob[cnt].callback = lcs_get_frames_cb;
0230         card->read.iob[cnt].state = LCS_BUF_STATE_READY;
0231         card->read.iob[cnt].count = LCS_IOBUFFERSIZE;
0232     }
0233     card->read.ccws[0].flags &= ~CCW_FLAG_PCI;
0234     card->read.ccws[LCS_NUM_BUFFS - 1].flags &= ~CCW_FLAG_PCI;
0235     card->read.ccws[LCS_NUM_BUFFS - 1].flags |= CCW_FLAG_SUSPEND;
0236     /* Last ccw is a tic (transfer in channel). */
0237     card->read.ccws[LCS_NUM_BUFFS].cmd_code = LCS_CCW_TRANSFER;
0238     card->read.ccws[LCS_NUM_BUFFS].cda =
0239         (__u32)virt_to_phys(card->read.ccws);
0240     /* Setg initial state of the read channel. */
0241     card->read.state = LCS_CH_STATE_INIT;
0242 
0243     card->read.io_idx = 0;
0244     card->read.buf_idx = 0;
0245 }
0246 
0247 static void
0248 lcs_setup_read(struct lcs_card *card)
0249 {
0250     LCS_DBF_TEXT(3, setup, "initread");
0251 
0252     lcs_setup_read_ccws(card);
0253     /* Initialize read channel tasklet. */
0254     card->read.irq_tasklet.data = (unsigned long) &card->read;
0255     card->read.irq_tasklet.func = lcs_tasklet;
0256     /* Initialize waitqueue. */
0257     init_waitqueue_head(&card->read.wait_q);
0258 }
0259 
0260 /*
0261  * Setup write channel.
0262  */
0263 static void
0264 lcs_setup_write_ccws(struct lcs_card *card)
0265 {
0266     int cnt;
0267 
0268     LCS_DBF_TEXT(3, setup, "iwritccw");
0269     /* Setup write ccws. */
0270     memset(card->write.ccws, 0, sizeof(struct ccw1) * (LCS_NUM_BUFFS + 1));
0271     for (cnt = 0; cnt < LCS_NUM_BUFFS; cnt++) {
0272         card->write.ccws[cnt].cmd_code = LCS_CCW_WRITE;
0273         card->write.ccws[cnt].count = 0;
0274         card->write.ccws[cnt].flags =
0275             CCW_FLAG_SUSPEND | CCW_FLAG_CC | CCW_FLAG_SLI;
0276         /*
0277          * Note: we have allocated the buffer with GFP_DMA, so
0278          * we do not need to do set_normalized_cda.
0279          */
0280         card->write.ccws[cnt].cda =
0281             (__u32)virt_to_phys(card->write.iob[cnt].data);
0282     }
0283     /* Last ccw is a tic (transfer in channel). */
0284     card->write.ccws[LCS_NUM_BUFFS].cmd_code = LCS_CCW_TRANSFER;
0285     card->write.ccws[LCS_NUM_BUFFS].cda =
0286         (__u32)virt_to_phys(card->write.ccws);
0287     /* Set initial state of the write channel. */
0288     card->read.state = LCS_CH_STATE_INIT;
0289 
0290     card->write.io_idx = 0;
0291     card->write.buf_idx = 0;
0292 }
0293 
0294 static void
0295 lcs_setup_write(struct lcs_card *card)
0296 {
0297     LCS_DBF_TEXT(3, setup, "initwrit");
0298 
0299     lcs_setup_write_ccws(card);
0300     /* Initialize write channel tasklet. */
0301     card->write.irq_tasklet.data = (unsigned long) &card->write;
0302     card->write.irq_tasklet.func = lcs_tasklet;
0303     /* Initialize waitqueue. */
0304     init_waitqueue_head(&card->write.wait_q);
0305 }
0306 
0307 static void
0308 lcs_set_allowed_threads(struct lcs_card *card, unsigned long threads)
0309 {
0310     unsigned long flags;
0311 
0312     spin_lock_irqsave(&card->mask_lock, flags);
0313     card->thread_allowed_mask = threads;
0314     spin_unlock_irqrestore(&card->mask_lock, flags);
0315     wake_up(&card->wait_q);
0316 }
0317 static int lcs_threads_running(struct lcs_card *card, unsigned long threads)
0318 {
0319         unsigned long flags;
0320         int rc = 0;
0321 
0322     spin_lock_irqsave(&card->mask_lock, flags);
0323         rc = (card->thread_running_mask & threads);
0324     spin_unlock_irqrestore(&card->mask_lock, flags);
0325         return rc;
0326 }
0327 
0328 static int
0329 lcs_wait_for_threads(struct lcs_card *card, unsigned long threads)
0330 {
0331         return wait_event_interruptible(card->wait_q,
0332                         lcs_threads_running(card, threads) == 0);
0333 }
0334 
0335 static int lcs_set_thread_start_bit(struct lcs_card *card, unsigned long thread)
0336 {
0337         unsigned long flags;
0338 
0339     spin_lock_irqsave(&card->mask_lock, flags);
0340         if ( !(card->thread_allowed_mask & thread) ||
0341               (card->thread_start_mask & thread) ) {
0342                 spin_unlock_irqrestore(&card->mask_lock, flags);
0343                 return -EPERM;
0344         }
0345         card->thread_start_mask |= thread;
0346     spin_unlock_irqrestore(&card->mask_lock, flags);
0347         return 0;
0348 }
0349 
0350 static void
0351 lcs_clear_thread_running_bit(struct lcs_card *card, unsigned long thread)
0352 {
0353         unsigned long flags;
0354 
0355     spin_lock_irqsave(&card->mask_lock, flags);
0356         card->thread_running_mask &= ~thread;
0357     spin_unlock_irqrestore(&card->mask_lock, flags);
0358         wake_up(&card->wait_q);
0359 }
0360 
0361 static int __lcs_do_run_thread(struct lcs_card *card, unsigned long thread)
0362 {
0363         unsigned long flags;
0364         int rc = 0;
0365 
0366     spin_lock_irqsave(&card->mask_lock, flags);
0367         if (card->thread_start_mask & thread){
0368                 if ((card->thread_allowed_mask & thread) &&
0369                     !(card->thread_running_mask & thread)){
0370                         rc = 1;
0371                         card->thread_start_mask &= ~thread;
0372                         card->thread_running_mask |= thread;
0373                 } else
0374                         rc = -EPERM;
0375         }
0376     spin_unlock_irqrestore(&card->mask_lock, flags);
0377         return rc;
0378 }
0379 
0380 static int
0381 lcs_do_run_thread(struct lcs_card *card, unsigned long thread)
0382 {
0383         int rc = 0;
0384         wait_event(card->wait_q,
0385                    (rc = __lcs_do_run_thread(card, thread)) >= 0);
0386         return rc;
0387 }
0388 
0389 static int
0390 lcs_do_start_thread(struct lcs_card *card, unsigned long thread)
0391 {
0392         unsigned long flags;
0393         int rc = 0;
0394 
0395     spin_lock_irqsave(&card->mask_lock, flags);
0396         LCS_DBF_TEXT_(4, trace, "  %02x%02x%02x",
0397                         (u8) card->thread_start_mask,
0398                         (u8) card->thread_allowed_mask,
0399                         (u8) card->thread_running_mask);
0400         rc = (card->thread_start_mask & thread);
0401     spin_unlock_irqrestore(&card->mask_lock, flags);
0402         return rc;
0403 }
0404 
0405 /*
0406  * Initialize channels,card and state machines.
0407  */
0408 static void
0409 lcs_setup_card(struct lcs_card *card)
0410 {
0411     LCS_DBF_TEXT(2, setup, "initcard");
0412     LCS_DBF_HEX(2, setup, &card, sizeof(void*));
0413 
0414     lcs_setup_read(card);
0415     lcs_setup_write(card);
0416     /* Set cards initial state. */
0417     card->state = DEV_STATE_DOWN;
0418     card->tx_buffer = NULL;
0419     card->tx_emitted = 0;
0420 
0421     init_waitqueue_head(&card->wait_q);
0422     spin_lock_init(&card->lock);
0423     spin_lock_init(&card->ipm_lock);
0424     spin_lock_init(&card->mask_lock);
0425 #ifdef CONFIG_IP_MULTICAST
0426     INIT_LIST_HEAD(&card->ipm_list);
0427 #endif
0428     INIT_LIST_HEAD(&card->lancmd_waiters);
0429 }
0430 
0431 static void lcs_clear_multicast_list(struct lcs_card *card)
0432 {
0433 #ifdef  CONFIG_IP_MULTICAST
0434     struct lcs_ipm_list *ipm;
0435     unsigned long flags;
0436 
0437     /* Free multicast list. */
0438     LCS_DBF_TEXT(3, setup, "clmclist");
0439     spin_lock_irqsave(&card->ipm_lock, flags);
0440     while (!list_empty(&card->ipm_list)){
0441         ipm = list_entry(card->ipm_list.next,
0442                  struct lcs_ipm_list, list);
0443         list_del(&ipm->list);
0444         if (ipm->ipm_state != LCS_IPM_STATE_SET_REQUIRED){
0445             spin_unlock_irqrestore(&card->ipm_lock, flags);
0446             lcs_send_delipm(card, ipm);
0447             spin_lock_irqsave(&card->ipm_lock, flags);
0448         }
0449         kfree(ipm);
0450     }
0451     spin_unlock_irqrestore(&card->ipm_lock, flags);
0452 #endif
0453 }
0454 
0455 /*
0456  * Cleanup channels,card and state machines.
0457  */
0458 static void
0459 lcs_cleanup_card(struct lcs_card *card)
0460 {
0461 
0462     LCS_DBF_TEXT(3, setup, "cleancrd");
0463     LCS_DBF_HEX(2,setup,&card,sizeof(void*));
0464 
0465     if (card->dev != NULL)
0466         free_netdev(card->dev);
0467     /* Cleanup channels. */
0468     lcs_cleanup_channel(&card->write);
0469     lcs_cleanup_channel(&card->read);
0470 }
0471 
0472 /*
0473  * Start channel.
0474  */
0475 static int
0476 lcs_start_channel(struct lcs_channel *channel)
0477 {
0478     unsigned long flags;
0479     int rc;
0480 
0481     LCS_DBF_TEXT_(4, trace,"ssch%s", dev_name(&channel->ccwdev->dev));
0482     spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
0483     rc = ccw_device_start(channel->ccwdev,
0484                   channel->ccws + channel->io_idx, 0, 0,
0485                   DOIO_DENY_PREFETCH | DOIO_ALLOW_SUSPEND);
0486     if (rc == 0)
0487         channel->state = LCS_CH_STATE_RUNNING;
0488     spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
0489     if (rc) {
0490         LCS_DBF_TEXT_(4,trace,"essh%s",
0491                   dev_name(&channel->ccwdev->dev));
0492         dev_err(&channel->ccwdev->dev,
0493             "Starting an LCS device resulted in an error,"
0494             " rc=%d!\n", rc);
0495     }
0496     return rc;
0497 }
0498 
0499 static int
0500 lcs_clear_channel(struct lcs_channel *channel)
0501 {
0502     unsigned long flags;
0503     int rc;
0504 
0505     LCS_DBF_TEXT(4,trace,"clearch");
0506     LCS_DBF_TEXT_(4, trace, "%s", dev_name(&channel->ccwdev->dev));
0507     spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
0508     rc = ccw_device_clear(channel->ccwdev, 0);
0509     spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
0510     if (rc) {
0511         LCS_DBF_TEXT_(4, trace, "ecsc%s",
0512                   dev_name(&channel->ccwdev->dev));
0513         return rc;
0514     }
0515     wait_event(channel->wait_q, (channel->state == LCS_CH_STATE_CLEARED));
0516     channel->state = LCS_CH_STATE_STOPPED;
0517     return rc;
0518 }
0519 
0520 
0521 /*
0522  * Stop channel.
0523  */
0524 static int
0525 lcs_stop_channel(struct lcs_channel *channel)
0526 {
0527     unsigned long flags;
0528     int rc;
0529 
0530     if (channel->state == LCS_CH_STATE_STOPPED)
0531         return 0;
0532     LCS_DBF_TEXT(4,trace,"haltsch");
0533     LCS_DBF_TEXT_(4, trace, "%s", dev_name(&channel->ccwdev->dev));
0534     channel->state = LCS_CH_STATE_INIT;
0535     spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
0536     rc = ccw_device_halt(channel->ccwdev, 0);
0537     spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
0538     if (rc) {
0539         LCS_DBF_TEXT_(4, trace, "ehsc%s",
0540                   dev_name(&channel->ccwdev->dev));
0541         return rc;
0542     }
0543     /* Asynchronous halt initialted. Wait for its completion. */
0544     wait_event(channel->wait_q, (channel->state == LCS_CH_STATE_HALTED));
0545     lcs_clear_channel(channel);
0546     return 0;
0547 }
0548 
0549 /*
0550  * start read and write channel
0551  */
0552 static int
0553 lcs_start_channels(struct lcs_card *card)
0554 {
0555     int rc;
0556 
0557     LCS_DBF_TEXT(2, trace, "chstart");
0558     /* start read channel */
0559     rc = lcs_start_channel(&card->read);
0560     if (rc)
0561         return rc;
0562     /* start write channel */
0563     rc = lcs_start_channel(&card->write);
0564     if (rc)
0565         lcs_stop_channel(&card->read);
0566     return rc;
0567 }
0568 
0569 /*
0570  * stop read and write channel
0571  */
0572 static int
0573 lcs_stop_channels(struct lcs_card *card)
0574 {
0575     LCS_DBF_TEXT(2, trace, "chhalt");
0576     lcs_stop_channel(&card->read);
0577     lcs_stop_channel(&card->write);
0578     return 0;
0579 }
0580 
0581 /*
0582  * Get empty buffer.
0583  */
0584 static struct lcs_buffer *
0585 __lcs_get_buffer(struct lcs_channel *channel)
0586 {
0587     int index;
0588 
0589     LCS_DBF_TEXT(5, trace, "_getbuff");
0590     index = channel->io_idx;
0591     do {
0592         if (channel->iob[index].state == LCS_BUF_STATE_EMPTY) {
0593             channel->iob[index].state = LCS_BUF_STATE_LOCKED;
0594             return channel->iob + index;
0595         }
0596         index = (index + 1) & (LCS_NUM_BUFFS - 1);
0597     } while (index != channel->io_idx);
0598     return NULL;
0599 }
0600 
0601 static struct lcs_buffer *
0602 lcs_get_buffer(struct lcs_channel *channel)
0603 {
0604     struct lcs_buffer *buffer;
0605     unsigned long flags;
0606 
0607     LCS_DBF_TEXT(5, trace, "getbuff");
0608     spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
0609     buffer = __lcs_get_buffer(channel);
0610     spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
0611     return buffer;
0612 }
0613 
0614 /*
0615  * Resume channel program if the channel is suspended.
0616  */
0617 static int
0618 __lcs_resume_channel(struct lcs_channel *channel)
0619 {
0620     int rc;
0621 
0622     if (channel->state != LCS_CH_STATE_SUSPENDED)
0623         return 0;
0624     if (channel->ccws[channel->io_idx].flags & CCW_FLAG_SUSPEND)
0625         return 0;
0626     LCS_DBF_TEXT_(5, trace, "rsch%s", dev_name(&channel->ccwdev->dev));
0627     rc = ccw_device_resume(channel->ccwdev);
0628     if (rc) {
0629         LCS_DBF_TEXT_(4, trace, "ersc%s",
0630                   dev_name(&channel->ccwdev->dev));
0631         dev_err(&channel->ccwdev->dev,
0632             "Sending data from the LCS device to the LAN failed"
0633             " with rc=%d\n",rc);
0634     } else
0635         channel->state = LCS_CH_STATE_RUNNING;
0636     return rc;
0637 
0638 }
0639 
0640 /*
0641  * Make a buffer ready for processing.
0642  */
0643 static void __lcs_ready_buffer_bits(struct lcs_channel *channel, int index)
0644 {
0645     int prev, next;
0646 
0647     LCS_DBF_TEXT(5, trace, "rdybits");
0648     prev = (index - 1) & (LCS_NUM_BUFFS - 1);
0649     next = (index + 1) & (LCS_NUM_BUFFS - 1);
0650     /* Check if we may clear the suspend bit of this buffer. */
0651     if (channel->ccws[next].flags & CCW_FLAG_SUSPEND) {
0652         /* Check if we have to set the PCI bit. */
0653         if (!(channel->ccws[prev].flags & CCW_FLAG_SUSPEND))
0654             /* Suspend bit of the previous buffer is not set. */
0655             channel->ccws[index].flags |= CCW_FLAG_PCI;
0656         /* Suspend bit of the next buffer is set. */
0657         channel->ccws[index].flags &= ~CCW_FLAG_SUSPEND;
0658     }
0659 }
0660 
0661 static int
0662 lcs_ready_buffer(struct lcs_channel *channel, struct lcs_buffer *buffer)
0663 {
0664     unsigned long flags;
0665     int index, rc;
0666 
0667     LCS_DBF_TEXT(5, trace, "rdybuff");
0668     BUG_ON(buffer->state != LCS_BUF_STATE_LOCKED &&
0669            buffer->state != LCS_BUF_STATE_PROCESSED);
0670     spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
0671     buffer->state = LCS_BUF_STATE_READY;
0672     index = buffer - channel->iob;
0673     /* Set length. */
0674     channel->ccws[index].count = buffer->count;
0675     /* Check relevant PCI/suspend bits. */
0676     __lcs_ready_buffer_bits(channel, index);
0677     rc = __lcs_resume_channel(channel);
0678     spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
0679     return rc;
0680 }
0681 
0682 /*
0683  * Mark the buffer as processed. Take care of the suspend bit
0684  * of the previous buffer. This function is called from
0685  * interrupt context, so the lock must not be taken.
0686  */
0687 static int
0688 __lcs_processed_buffer(struct lcs_channel *channel, struct lcs_buffer *buffer)
0689 {
0690     int index, prev, next;
0691 
0692     LCS_DBF_TEXT(5, trace, "prcsbuff");
0693     BUG_ON(buffer->state != LCS_BUF_STATE_READY);
0694     buffer->state = LCS_BUF_STATE_PROCESSED;
0695     index = buffer - channel->iob;
0696     prev = (index - 1) & (LCS_NUM_BUFFS - 1);
0697     next = (index + 1) & (LCS_NUM_BUFFS - 1);
0698     /* Set the suspend bit and clear the PCI bit of this buffer. */
0699     channel->ccws[index].flags |= CCW_FLAG_SUSPEND;
0700     channel->ccws[index].flags &= ~CCW_FLAG_PCI;
0701     /* Check the suspend bit of the previous buffer. */
0702     if (channel->iob[prev].state == LCS_BUF_STATE_READY) {
0703         /*
0704          * Previous buffer is in state ready. It might have
0705          * happened in lcs_ready_buffer that the suspend bit
0706          * has not been cleared to avoid an endless loop.
0707          * Do it now.
0708          */
0709         __lcs_ready_buffer_bits(channel, prev);
0710     }
0711     /* Clear PCI bit of next buffer. */
0712     channel->ccws[next].flags &= ~CCW_FLAG_PCI;
0713     return __lcs_resume_channel(channel);
0714 }
0715 
0716 /*
0717  * Put a processed buffer back to state empty.
0718  */
0719 static void
0720 lcs_release_buffer(struct lcs_channel *channel, struct lcs_buffer *buffer)
0721 {
0722     unsigned long flags;
0723 
0724     LCS_DBF_TEXT(5, trace, "relbuff");
0725     BUG_ON(buffer->state != LCS_BUF_STATE_LOCKED &&
0726            buffer->state != LCS_BUF_STATE_PROCESSED);
0727     spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
0728     buffer->state = LCS_BUF_STATE_EMPTY;
0729     spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
0730 }
0731 
0732 /*
0733  * Get buffer for a lan command.
0734  */
0735 static struct lcs_buffer *
0736 lcs_get_lancmd(struct lcs_card *card, int count)
0737 {
0738     struct lcs_buffer *buffer;
0739     struct lcs_cmd *cmd;
0740 
0741     LCS_DBF_TEXT(4, trace, "getlncmd");
0742     /* Get buffer and wait if none is available. */
0743     wait_event(card->write.wait_q,
0744            ((buffer = lcs_get_buffer(&card->write)) != NULL));
0745     count += sizeof(struct lcs_header);
0746     *(__u16 *)(buffer->data + count) = 0;
0747     buffer->count = count + sizeof(__u16);
0748     buffer->callback = lcs_release_buffer;
0749     cmd = (struct lcs_cmd *) buffer->data;
0750     cmd->offset = count;
0751     cmd->type = LCS_FRAME_TYPE_CONTROL;
0752     cmd->slot = 0;
0753     return buffer;
0754 }
0755 
0756 
0757 static void
0758 lcs_get_reply(struct lcs_reply *reply)
0759 {
0760     refcount_inc(&reply->refcnt);
0761 }
0762 
0763 static void
0764 lcs_put_reply(struct lcs_reply *reply)
0765 {
0766     if (refcount_dec_and_test(&reply->refcnt))
0767         kfree(reply);
0768 }
0769 
0770 static struct lcs_reply *
0771 lcs_alloc_reply(struct lcs_cmd *cmd)
0772 {
0773     struct lcs_reply *reply;
0774 
0775     LCS_DBF_TEXT(4, trace, "getreply");
0776 
0777     reply = kzalloc(sizeof(struct lcs_reply), GFP_ATOMIC);
0778     if (!reply)
0779         return NULL;
0780     refcount_set(&reply->refcnt, 1);
0781     reply->sequence_no = cmd->sequence_no;
0782     reply->received = 0;
0783     reply->rc = 0;
0784     init_waitqueue_head(&reply->wait_q);
0785 
0786     return reply;
0787 }
0788 
0789 /*
0790  * Notifier function for lancmd replies. Called from read irq.
0791  */
0792 static void
0793 lcs_notify_lancmd_waiters(struct lcs_card *card, struct lcs_cmd *cmd)
0794 {
0795     struct list_head *l, *n;
0796     struct lcs_reply *reply;
0797 
0798     LCS_DBF_TEXT(4, trace, "notiwait");
0799     spin_lock(&card->lock);
0800     list_for_each_safe(l, n, &card->lancmd_waiters) {
0801         reply = list_entry(l, struct lcs_reply, list);
0802         if (reply->sequence_no == cmd->sequence_no) {
0803             lcs_get_reply(reply);
0804             list_del_init(&reply->list);
0805             if (reply->callback != NULL)
0806                 reply->callback(card, cmd);
0807             reply->received = 1;
0808             reply->rc = cmd->return_code;
0809             wake_up(&reply->wait_q);
0810             lcs_put_reply(reply);
0811             break;
0812         }
0813     }
0814     spin_unlock(&card->lock);
0815 }
0816 
0817 /*
0818  * Emit buffer of a lan command.
0819  */
0820 static void
0821 lcs_lancmd_timeout(struct timer_list *t)
0822 {
0823     struct lcs_reply *reply = from_timer(reply, t, timer);
0824     struct lcs_reply *list_reply, *r;
0825     unsigned long flags;
0826 
0827     LCS_DBF_TEXT(4, trace, "timeout");
0828     spin_lock_irqsave(&reply->card->lock, flags);
0829     list_for_each_entry_safe(list_reply, r,
0830                  &reply->card->lancmd_waiters,list) {
0831         if (reply == list_reply) {
0832             lcs_get_reply(reply);
0833             list_del_init(&reply->list);
0834             spin_unlock_irqrestore(&reply->card->lock, flags);
0835             reply->received = 1;
0836             reply->rc = -ETIME;
0837             wake_up(&reply->wait_q);
0838             lcs_put_reply(reply);
0839             return;
0840         }
0841     }
0842     spin_unlock_irqrestore(&reply->card->lock, flags);
0843 }
0844 
0845 static int
0846 lcs_send_lancmd(struct lcs_card *card, struct lcs_buffer *buffer,
0847         void (*reply_callback)(struct lcs_card *, struct lcs_cmd *))
0848 {
0849     struct lcs_reply *reply;
0850     struct lcs_cmd *cmd;
0851     unsigned long flags;
0852     int rc;
0853 
0854     LCS_DBF_TEXT(4, trace, "sendcmd");
0855     cmd = (struct lcs_cmd *) buffer->data;
0856     cmd->return_code = 0;
0857     cmd->sequence_no = card->sequence_no++;
0858     reply = lcs_alloc_reply(cmd);
0859     if (!reply)
0860         return -ENOMEM;
0861     reply->callback = reply_callback;
0862     reply->card = card;
0863     spin_lock_irqsave(&card->lock, flags);
0864     list_add_tail(&reply->list, &card->lancmd_waiters);
0865     spin_unlock_irqrestore(&card->lock, flags);
0866 
0867     buffer->callback = lcs_release_buffer;
0868     rc = lcs_ready_buffer(&card->write, buffer);
0869     if (rc)
0870         return rc;
0871     timer_setup(&reply->timer, lcs_lancmd_timeout, 0);
0872     mod_timer(&reply->timer, jiffies + HZ * card->lancmd_timeout);
0873     wait_event(reply->wait_q, reply->received);
0874     del_timer_sync(&reply->timer);
0875     LCS_DBF_TEXT_(4, trace, "rc:%d",reply->rc);
0876     rc = reply->rc;
0877     lcs_put_reply(reply);
0878     return rc ? -EIO : 0;
0879 }
0880 
0881 /*
0882  * LCS startup command
0883  */
0884 static int
0885 lcs_send_startup(struct lcs_card *card, __u8 initiator)
0886 {
0887     struct lcs_buffer *buffer;
0888     struct lcs_cmd *cmd;
0889 
0890     LCS_DBF_TEXT(2, trace, "startup");
0891     buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
0892     cmd = (struct lcs_cmd *) buffer->data;
0893     cmd->cmd_code = LCS_CMD_STARTUP;
0894     cmd->initiator = initiator;
0895     cmd->cmd.lcs_startup.buff_size = LCS_IOBUFFERSIZE;
0896     return lcs_send_lancmd(card, buffer, NULL);
0897 }
0898 
0899 /*
0900  * LCS shutdown command
0901  */
0902 static int
0903 lcs_send_shutdown(struct lcs_card *card)
0904 {
0905     struct lcs_buffer *buffer;
0906     struct lcs_cmd *cmd;
0907 
0908     LCS_DBF_TEXT(2, trace, "shutdown");
0909     buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
0910     cmd = (struct lcs_cmd *) buffer->data;
0911     cmd->cmd_code = LCS_CMD_SHUTDOWN;
0912     cmd->initiator = LCS_INITIATOR_TCPIP;
0913     return lcs_send_lancmd(card, buffer, NULL);
0914 }
0915 
0916 /*
0917  * LCS lanstat command
0918  */
0919 static void
0920 __lcs_lanstat_cb(struct lcs_card *card, struct lcs_cmd *cmd)
0921 {
0922     LCS_DBF_TEXT(2, trace, "statcb");
0923     memcpy(card->mac, cmd->cmd.lcs_lanstat_cmd.mac_addr, LCS_MAC_LENGTH);
0924 }
0925 
0926 static int
0927 lcs_send_lanstat(struct lcs_card *card)
0928 {
0929     struct lcs_buffer *buffer;
0930     struct lcs_cmd *cmd;
0931 
0932     LCS_DBF_TEXT(2,trace, "cmdstat");
0933     buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
0934     cmd = (struct lcs_cmd *) buffer->data;
0935     /* Setup lanstat command. */
0936     cmd->cmd_code = LCS_CMD_LANSTAT;
0937     cmd->initiator = LCS_INITIATOR_TCPIP;
0938     cmd->cmd.lcs_std_cmd.lan_type = card->lan_type;
0939     cmd->cmd.lcs_std_cmd.portno = card->portno;
0940     return lcs_send_lancmd(card, buffer, __lcs_lanstat_cb);
0941 }
0942 
0943 /*
0944  * send stoplan command
0945  */
0946 static int
0947 lcs_send_stoplan(struct lcs_card *card, __u8 initiator)
0948 {
0949     struct lcs_buffer *buffer;
0950     struct lcs_cmd *cmd;
0951 
0952     LCS_DBF_TEXT(2, trace, "cmdstpln");
0953     buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
0954     cmd = (struct lcs_cmd *) buffer->data;
0955     cmd->cmd_code = LCS_CMD_STOPLAN;
0956     cmd->initiator = initiator;
0957     cmd->cmd.lcs_std_cmd.lan_type = card->lan_type;
0958     cmd->cmd.lcs_std_cmd.portno = card->portno;
0959     return lcs_send_lancmd(card, buffer, NULL);
0960 }
0961 
0962 /*
0963  * send startlan command
0964  */
0965 static void
0966 __lcs_send_startlan_cb(struct lcs_card *card, struct lcs_cmd *cmd)
0967 {
0968     LCS_DBF_TEXT(2, trace, "srtlancb");
0969     card->lan_type = cmd->cmd.lcs_std_cmd.lan_type;
0970     card->portno = cmd->cmd.lcs_std_cmd.portno;
0971 }
0972 
0973 static int
0974 lcs_send_startlan(struct lcs_card *card, __u8 initiator)
0975 {
0976     struct lcs_buffer *buffer;
0977     struct lcs_cmd *cmd;
0978 
0979     LCS_DBF_TEXT(2, trace, "cmdstaln");
0980     buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
0981     cmd = (struct lcs_cmd *) buffer->data;
0982     cmd->cmd_code = LCS_CMD_STARTLAN;
0983     cmd->initiator = initiator;
0984     cmd->cmd.lcs_std_cmd.lan_type = card->lan_type;
0985     cmd->cmd.lcs_std_cmd.portno = card->portno;
0986     return lcs_send_lancmd(card, buffer, __lcs_send_startlan_cb);
0987 }
0988 
0989 #ifdef CONFIG_IP_MULTICAST
0990 /*
0991  * send setipm command (Multicast)
0992  */
0993 static int
0994 lcs_send_setipm(struct lcs_card *card,struct lcs_ipm_list *ipm_list)
0995 {
0996     struct lcs_buffer *buffer;
0997     struct lcs_cmd *cmd;
0998 
0999     LCS_DBF_TEXT(2, trace, "cmdsetim");
1000     buffer = lcs_get_lancmd(card, LCS_MULTICAST_CMD_SIZE);
1001     cmd = (struct lcs_cmd *) buffer->data;
1002     cmd->cmd_code = LCS_CMD_SETIPM;
1003     cmd->initiator = LCS_INITIATOR_TCPIP;
1004     cmd->cmd.lcs_qipassist.lan_type = card->lan_type;
1005     cmd->cmd.lcs_qipassist.portno = card->portno;
1006     cmd->cmd.lcs_qipassist.version = 4;
1007     cmd->cmd.lcs_qipassist.num_ip_pairs = 1;
1008     memcpy(cmd->cmd.lcs_qipassist.lcs_ipass_ctlmsg.ip_mac_pair,
1009            &ipm_list->ipm, sizeof (struct lcs_ip_mac_pair));
1010     LCS_DBF_TEXT_(2, trace, "%x",ipm_list->ipm.ip_addr);
1011     return lcs_send_lancmd(card, buffer, NULL);
1012 }
1013 
1014 /*
1015  * send delipm command (Multicast)
1016  */
1017 static int
1018 lcs_send_delipm(struct lcs_card *card,struct lcs_ipm_list *ipm_list)
1019 {
1020     struct lcs_buffer *buffer;
1021     struct lcs_cmd *cmd;
1022 
1023     LCS_DBF_TEXT(2, trace, "cmddelim");
1024     buffer = lcs_get_lancmd(card, LCS_MULTICAST_CMD_SIZE);
1025     cmd = (struct lcs_cmd *) buffer->data;
1026     cmd->cmd_code = LCS_CMD_DELIPM;
1027     cmd->initiator = LCS_INITIATOR_TCPIP;
1028     cmd->cmd.lcs_qipassist.lan_type = card->lan_type;
1029     cmd->cmd.lcs_qipassist.portno = card->portno;
1030     cmd->cmd.lcs_qipassist.version = 4;
1031     cmd->cmd.lcs_qipassist.num_ip_pairs = 1;
1032     memcpy(cmd->cmd.lcs_qipassist.lcs_ipass_ctlmsg.ip_mac_pair,
1033            &ipm_list->ipm, sizeof (struct lcs_ip_mac_pair));
1034     LCS_DBF_TEXT_(2, trace, "%x",ipm_list->ipm.ip_addr);
1035     return lcs_send_lancmd(card, buffer, NULL);
1036 }
1037 
1038 /*
1039  * check if multicast is supported by LCS
1040  */
1041 static void
1042 __lcs_check_multicast_cb(struct lcs_card *card, struct lcs_cmd *cmd)
1043 {
1044     LCS_DBF_TEXT(2, trace, "chkmccb");
1045     card->ip_assists_supported =
1046         cmd->cmd.lcs_qipassist.ip_assists_supported;
1047     card->ip_assists_enabled =
1048         cmd->cmd.lcs_qipassist.ip_assists_enabled;
1049 }
1050 
1051 static int
1052 lcs_check_multicast_support(struct lcs_card *card)
1053 {
1054     struct lcs_buffer *buffer;
1055     struct lcs_cmd *cmd;
1056     int rc;
1057 
1058     LCS_DBF_TEXT(2, trace, "cmdqipa");
1059     /* Send query ipassist. */
1060     buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
1061     cmd = (struct lcs_cmd *) buffer->data;
1062     cmd->cmd_code = LCS_CMD_QIPASSIST;
1063     cmd->initiator = LCS_INITIATOR_TCPIP;
1064     cmd->cmd.lcs_qipassist.lan_type = card->lan_type;
1065     cmd->cmd.lcs_qipassist.portno = card->portno;
1066     cmd->cmd.lcs_qipassist.version = 4;
1067     cmd->cmd.lcs_qipassist.num_ip_pairs = 1;
1068     rc = lcs_send_lancmd(card, buffer, __lcs_check_multicast_cb);
1069     if (rc != 0) {
1070         pr_err("Query IPAssist failed. Assuming unsupported!\n");
1071         return -EOPNOTSUPP;
1072     }
1073     if (card->ip_assists_supported & LCS_IPASS_MULTICAST_SUPPORT)
1074         return 0;
1075     return -EOPNOTSUPP;
1076 }
1077 
1078 /*
1079  * set or del multicast address on LCS card
1080  */
1081 static void
1082 lcs_fix_multicast_list(struct lcs_card *card)
1083 {
1084     struct list_head failed_list;
1085     struct lcs_ipm_list *ipm, *tmp;
1086     unsigned long flags;
1087     int rc;
1088 
1089     LCS_DBF_TEXT(4,trace, "fixipm");
1090     INIT_LIST_HEAD(&failed_list);
1091     spin_lock_irqsave(&card->ipm_lock, flags);
1092 list_modified:
1093     list_for_each_entry_safe(ipm, tmp, &card->ipm_list, list){
1094         switch (ipm->ipm_state) {
1095         case LCS_IPM_STATE_SET_REQUIRED:
1096             /* del from ipm_list so no one else can tamper with
1097              * this entry */
1098             list_del_init(&ipm->list);
1099             spin_unlock_irqrestore(&card->ipm_lock, flags);
1100             rc = lcs_send_setipm(card, ipm);
1101             spin_lock_irqsave(&card->ipm_lock, flags);
1102             if (rc) {
1103                 pr_info("Adding multicast address failed."
1104                     " Table possibly full!\n");
1105                 /* store ipm in failed list -> will be added
1106                  * to ipm_list again, so a retry will be done
1107                  * during the next call of this function */
1108                 list_add_tail(&ipm->list, &failed_list);
1109             } else {
1110                 ipm->ipm_state = LCS_IPM_STATE_ON_CARD;
1111                 /* re-insert into ipm_list */
1112                 list_add_tail(&ipm->list, &card->ipm_list);
1113             }
1114             goto list_modified;
1115         case LCS_IPM_STATE_DEL_REQUIRED:
1116             list_del(&ipm->list);
1117             spin_unlock_irqrestore(&card->ipm_lock, flags);
1118             lcs_send_delipm(card, ipm);
1119             spin_lock_irqsave(&card->ipm_lock, flags);
1120             kfree(ipm);
1121             goto list_modified;
1122         case LCS_IPM_STATE_ON_CARD:
1123             break;
1124         }
1125     }
1126     /* re-insert all entries from the failed_list into ipm_list */
1127     list_for_each_entry_safe(ipm, tmp, &failed_list, list)
1128         list_move_tail(&ipm->list, &card->ipm_list);
1129 
1130     spin_unlock_irqrestore(&card->ipm_lock, flags);
1131 }
1132 
1133 /*
1134  * get mac address for the relevant Multicast address
1135  */
1136 static void
1137 lcs_get_mac_for_ipm(__be32 ipm, char *mac, struct net_device *dev)
1138 {
1139     LCS_DBF_TEXT(4,trace, "getmac");
1140     ip_eth_mc_map(ipm, mac);
1141 }
1142 
1143 /*
1144  * function called by net device to handle multicast address relevant things
1145  */
1146 static void lcs_remove_mc_addresses(struct lcs_card *card,
1147                     struct in_device *in4_dev)
1148 {
1149     struct ip_mc_list *im4;
1150     struct list_head *l;
1151     struct lcs_ipm_list *ipm;
1152     unsigned long flags;
1153     char buf[MAX_ADDR_LEN];
1154 
1155     LCS_DBF_TEXT(4, trace, "remmclst");
1156     spin_lock_irqsave(&card->ipm_lock, flags);
1157     list_for_each(l, &card->ipm_list) {
1158         ipm = list_entry(l, struct lcs_ipm_list, list);
1159         for (im4 = rcu_dereference(in4_dev->mc_list);
1160              im4 != NULL; im4 = rcu_dereference(im4->next_rcu)) {
1161             lcs_get_mac_for_ipm(im4->multiaddr, buf, card->dev);
1162             if ( (ipm->ipm.ip_addr == im4->multiaddr) &&
1163                  (memcmp(buf, &ipm->ipm.mac_addr,
1164                      LCS_MAC_LENGTH) == 0) )
1165                 break;
1166         }
1167         if (im4 == NULL)
1168             ipm->ipm_state = LCS_IPM_STATE_DEL_REQUIRED;
1169     }
1170     spin_unlock_irqrestore(&card->ipm_lock, flags);
1171 }
1172 
1173 static struct lcs_ipm_list *lcs_check_addr_entry(struct lcs_card *card,
1174                          struct ip_mc_list *im4,
1175                          char *buf)
1176 {
1177     struct lcs_ipm_list *tmp, *ipm = NULL;
1178     struct list_head *l;
1179     unsigned long flags;
1180 
1181     LCS_DBF_TEXT(4, trace, "chkmcent");
1182     spin_lock_irqsave(&card->ipm_lock, flags);
1183     list_for_each(l, &card->ipm_list) {
1184         tmp = list_entry(l, struct lcs_ipm_list, list);
1185         if ( (tmp->ipm.ip_addr == im4->multiaddr) &&
1186              (memcmp(buf, &tmp->ipm.mac_addr,
1187                  LCS_MAC_LENGTH) == 0) ) {
1188             ipm = tmp;
1189             break;
1190         }
1191     }
1192     spin_unlock_irqrestore(&card->ipm_lock, flags);
1193     return ipm;
1194 }
1195 
1196 static void lcs_set_mc_addresses(struct lcs_card *card,
1197                  struct in_device *in4_dev)
1198 {
1199 
1200     struct ip_mc_list *im4;
1201     struct lcs_ipm_list *ipm;
1202     char buf[MAX_ADDR_LEN];
1203     unsigned long flags;
1204 
1205     LCS_DBF_TEXT(4, trace, "setmclst");
1206     for (im4 = rcu_dereference(in4_dev->mc_list); im4 != NULL;
1207          im4 = rcu_dereference(im4->next_rcu)) {
1208         lcs_get_mac_for_ipm(im4->multiaddr, buf, card->dev);
1209         ipm = lcs_check_addr_entry(card, im4, buf);
1210         if (ipm != NULL)
1211             continue;   /* Address already in list. */
1212         ipm = kzalloc(sizeof(struct lcs_ipm_list), GFP_ATOMIC);
1213         if (ipm == NULL) {
1214             pr_info("Not enough memory to add"
1215                 " new multicast entry!\n");
1216             break;
1217         }
1218         memcpy(&ipm->ipm.mac_addr, buf, LCS_MAC_LENGTH);
1219         ipm->ipm.ip_addr = im4->multiaddr;
1220         ipm->ipm_state = LCS_IPM_STATE_SET_REQUIRED;
1221         spin_lock_irqsave(&card->ipm_lock, flags);
1222         LCS_DBF_HEX(2,trace,&ipm->ipm.ip_addr,4);
1223         list_add(&ipm->list, &card->ipm_list);
1224         spin_unlock_irqrestore(&card->ipm_lock, flags);
1225     }
1226 }
1227 
1228 static int
1229 lcs_register_mc_addresses(void *data)
1230 {
1231     struct lcs_card *card;
1232     struct in_device *in4_dev;
1233 
1234     card = (struct lcs_card *) data;
1235 
1236     if (!lcs_do_run_thread(card, LCS_SET_MC_THREAD))
1237         return 0;
1238     LCS_DBF_TEXT(4, trace, "regmulti");
1239 
1240     in4_dev = in_dev_get(card->dev);
1241     if (in4_dev == NULL)
1242         goto out;
1243     rcu_read_lock();
1244     lcs_remove_mc_addresses(card,in4_dev);
1245     lcs_set_mc_addresses(card, in4_dev);
1246     rcu_read_unlock();
1247     in_dev_put(in4_dev);
1248 
1249     netif_carrier_off(card->dev);
1250     netif_tx_disable(card->dev);
1251     wait_event(card->write.wait_q,
1252             (card->write.state != LCS_CH_STATE_RUNNING));
1253     lcs_fix_multicast_list(card);
1254     if (card->state == DEV_STATE_UP) {
1255         netif_carrier_on(card->dev);
1256         netif_wake_queue(card->dev);
1257     }
1258 out:
1259     lcs_clear_thread_running_bit(card, LCS_SET_MC_THREAD);
1260     return 0;
1261 }
1262 #endif /* CONFIG_IP_MULTICAST */
1263 
1264 /*
1265  * function called by net device to
1266  * handle multicast address relevant things
1267  */
1268 static void
1269 lcs_set_multicast_list(struct net_device *dev)
1270 {
1271 #ifdef CONFIG_IP_MULTICAST
1272         struct lcs_card *card;
1273 
1274         LCS_DBF_TEXT(4, trace, "setmulti");
1275         card = (struct lcs_card *) dev->ml_priv;
1276 
1277         if (!lcs_set_thread_start_bit(card, LCS_SET_MC_THREAD))
1278         schedule_work(&card->kernel_thread_starter);
1279 #endif /* CONFIG_IP_MULTICAST */
1280 }
1281 
1282 static long
1283 lcs_check_irb_error(struct ccw_device *cdev, struct irb *irb)
1284 {
1285     if (!IS_ERR(irb))
1286         return 0;
1287 
1288     switch (PTR_ERR(irb)) {
1289     case -EIO:
1290         dev_warn(&cdev->dev,
1291             "An I/O-error occurred on the LCS device\n");
1292         LCS_DBF_TEXT(2, trace, "ckirberr");
1293         LCS_DBF_TEXT_(2, trace, "  rc%d", -EIO);
1294         break;
1295     case -ETIMEDOUT:
1296         dev_warn(&cdev->dev,
1297             "A command timed out on the LCS device\n");
1298         LCS_DBF_TEXT(2, trace, "ckirberr");
1299         LCS_DBF_TEXT_(2, trace, "  rc%d", -ETIMEDOUT);
1300         break;
1301     default:
1302         dev_warn(&cdev->dev,
1303             "An error occurred on the LCS device, rc=%ld\n",
1304             PTR_ERR(irb));
1305         LCS_DBF_TEXT(2, trace, "ckirberr");
1306         LCS_DBF_TEXT(2, trace, "  rc???");
1307     }
1308     return PTR_ERR(irb);
1309 }
1310 
1311 static int
1312 lcs_get_problem(struct ccw_device *cdev, struct irb *irb)
1313 {
1314     int dstat, cstat;
1315     char *sense;
1316 
1317     sense = (char *) irb->ecw;
1318     cstat = irb->scsw.cmd.cstat;
1319     dstat = irb->scsw.cmd.dstat;
1320 
1321     if (cstat & (SCHN_STAT_CHN_CTRL_CHK | SCHN_STAT_INTF_CTRL_CHK |
1322              SCHN_STAT_CHN_DATA_CHK | SCHN_STAT_CHAIN_CHECK |
1323              SCHN_STAT_PROT_CHECK   | SCHN_STAT_PROG_CHECK)) {
1324         LCS_DBF_TEXT(2, trace, "CGENCHK");
1325         return 1;
1326     }
1327     if (dstat & DEV_STAT_UNIT_CHECK) {
1328         if (sense[LCS_SENSE_BYTE_1] &
1329             LCS_SENSE_RESETTING_EVENT) {
1330             LCS_DBF_TEXT(2, trace, "REVIND");
1331             return 1;
1332         }
1333         if (sense[LCS_SENSE_BYTE_0] &
1334             LCS_SENSE_CMD_REJECT) {
1335             LCS_DBF_TEXT(2, trace, "CMDREJ");
1336             return 0;
1337         }
1338         if ((!sense[LCS_SENSE_BYTE_0]) &&
1339             (!sense[LCS_SENSE_BYTE_1]) &&
1340             (!sense[LCS_SENSE_BYTE_2]) &&
1341             (!sense[LCS_SENSE_BYTE_3])) {
1342             LCS_DBF_TEXT(2, trace, "ZEROSEN");
1343             return 0;
1344         }
1345         LCS_DBF_TEXT(2, trace, "DGENCHK");
1346         return 1;
1347     }
1348     return 0;
1349 }
1350 
1351 static void
1352 lcs_schedule_recovery(struct lcs_card *card)
1353 {
1354     LCS_DBF_TEXT(2, trace, "startrec");
1355     if (!lcs_set_thread_start_bit(card, LCS_RECOVERY_THREAD))
1356         schedule_work(&card->kernel_thread_starter);
1357 }
1358 
1359 /*
1360  * IRQ Handler for LCS channels
1361  */
1362 static void
1363 lcs_irq(struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
1364 {
1365     struct lcs_card *card;
1366     struct lcs_channel *channel;
1367     int rc, index;
1368     int cstat, dstat;
1369 
1370     if (lcs_check_irb_error(cdev, irb))
1371         return;
1372 
1373     card = CARD_FROM_DEV(cdev);
1374     if (card->read.ccwdev == cdev)
1375         channel = &card->read;
1376     else
1377         channel = &card->write;
1378 
1379     cstat = irb->scsw.cmd.cstat;
1380     dstat = irb->scsw.cmd.dstat;
1381     LCS_DBF_TEXT_(5, trace, "Rint%s", dev_name(&cdev->dev));
1382     LCS_DBF_TEXT_(5, trace, "%4x%4x", irb->scsw.cmd.cstat,
1383               irb->scsw.cmd.dstat);
1384     LCS_DBF_TEXT_(5, trace, "%4x%4x", irb->scsw.cmd.fctl,
1385               irb->scsw.cmd.actl);
1386 
1387     /* Check for channel and device errors presented */
1388     rc = lcs_get_problem(cdev, irb);
1389     if (rc || (dstat & DEV_STAT_UNIT_EXCEP)) {
1390         dev_warn(&cdev->dev,
1391             "The LCS device stopped because of an error,"
1392             " dstat=0x%X, cstat=0x%X \n",
1393                 dstat, cstat);
1394         if (rc) {
1395             channel->state = LCS_CH_STATE_ERROR;
1396         }
1397     }
1398     if (channel->state == LCS_CH_STATE_ERROR) {
1399         lcs_schedule_recovery(card);
1400         wake_up(&card->wait_q);
1401         return;
1402     }
1403     /* How far in the ccw chain have we processed? */
1404     if ((channel->state != LCS_CH_STATE_INIT) &&
1405         (irb->scsw.cmd.fctl & SCSW_FCTL_START_FUNC) &&
1406         (irb->scsw.cmd.cpa != 0)) {
1407         index = (struct ccw1 *) __va((addr_t) irb->scsw.cmd.cpa)
1408             - channel->ccws;
1409         if ((irb->scsw.cmd.actl & SCSW_ACTL_SUSPENDED) ||
1410             (irb->scsw.cmd.cstat & SCHN_STAT_PCI))
1411             /* Bloody io subsystem tells us lies about cpa... */
1412             index = (index - 1) & (LCS_NUM_BUFFS - 1);
1413         while (channel->io_idx != index) {
1414             __lcs_processed_buffer(channel,
1415                            channel->iob + channel->io_idx);
1416             channel->io_idx =
1417                 (channel->io_idx + 1) & (LCS_NUM_BUFFS - 1);
1418         }
1419     }
1420 
1421     if ((irb->scsw.cmd.dstat & DEV_STAT_DEV_END) ||
1422         (irb->scsw.cmd.dstat & DEV_STAT_CHN_END) ||
1423         (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK))
1424         /* Mark channel as stopped. */
1425         channel->state = LCS_CH_STATE_STOPPED;
1426     else if (irb->scsw.cmd.actl & SCSW_ACTL_SUSPENDED)
1427         /* CCW execution stopped on a suspend bit. */
1428         channel->state = LCS_CH_STATE_SUSPENDED;
1429     if (irb->scsw.cmd.fctl & SCSW_FCTL_HALT_FUNC) {
1430         if (irb->scsw.cmd.cc != 0) {
1431             ccw_device_halt(channel->ccwdev, 0);
1432             return;
1433         }
1434         /* The channel has been stopped by halt_IO. */
1435         channel->state = LCS_CH_STATE_HALTED;
1436     }
1437     if (irb->scsw.cmd.fctl & SCSW_FCTL_CLEAR_FUNC)
1438         channel->state = LCS_CH_STATE_CLEARED;
1439     /* Do the rest in the tasklet. */
1440     tasklet_schedule(&channel->irq_tasklet);
1441 }
1442 
1443 /*
1444  * Tasklet for IRQ handler
1445  */
1446 static void
1447 lcs_tasklet(unsigned long data)
1448 {
1449     unsigned long flags;
1450     struct lcs_channel *channel;
1451     struct lcs_buffer *iob;
1452     int buf_idx;
1453 
1454     channel = (struct lcs_channel *) data;
1455     LCS_DBF_TEXT_(5, trace, "tlet%s", dev_name(&channel->ccwdev->dev));
1456 
1457     /* Check for processed buffers. */
1458     iob = channel->iob;
1459     buf_idx = channel->buf_idx;
1460     while (iob[buf_idx].state == LCS_BUF_STATE_PROCESSED) {
1461         /* Do the callback thing. */
1462         if (iob[buf_idx].callback != NULL)
1463             iob[buf_idx].callback(channel, iob + buf_idx);
1464         buf_idx = (buf_idx + 1) & (LCS_NUM_BUFFS - 1);
1465     }
1466     channel->buf_idx = buf_idx;
1467 
1468     if (channel->state == LCS_CH_STATE_STOPPED)
1469         lcs_start_channel(channel);
1470     spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
1471     if (channel->state == LCS_CH_STATE_SUSPENDED &&
1472         channel->iob[channel->io_idx].state == LCS_BUF_STATE_READY)
1473         __lcs_resume_channel(channel);
1474     spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
1475 
1476     /* Something happened on the channel. Wake up waiters. */
1477     wake_up(&channel->wait_q);
1478 }
1479 
1480 /*
1481  * Finish current tx buffer and make it ready for transmit.
1482  */
1483 static void
1484 __lcs_emit_txbuffer(struct lcs_card *card)
1485 {
1486     LCS_DBF_TEXT(5, trace, "emittx");
1487     *(__u16 *)(card->tx_buffer->data + card->tx_buffer->count) = 0;
1488     card->tx_buffer->count += 2;
1489     lcs_ready_buffer(&card->write, card->tx_buffer);
1490     card->tx_buffer = NULL;
1491     card->tx_emitted++;
1492 }
1493 
1494 /*
1495  * Callback for finished tx buffers.
1496  */
1497 static void
1498 lcs_txbuffer_cb(struct lcs_channel *channel, struct lcs_buffer *buffer)
1499 {
1500     struct lcs_card *card;
1501 
1502     LCS_DBF_TEXT(5, trace, "txbuffcb");
1503     /* Put buffer back to pool. */
1504     lcs_release_buffer(channel, buffer);
1505     card = container_of(channel, struct lcs_card, write);
1506     if (netif_queue_stopped(card->dev) && netif_carrier_ok(card->dev))
1507         netif_wake_queue(card->dev);
1508     spin_lock(&card->lock);
1509     card->tx_emitted--;
1510     if (card->tx_emitted <= 0 && card->tx_buffer != NULL)
1511         /*
1512          * Last running tx buffer has finished. Submit partially
1513          * filled current buffer.
1514          */
1515         __lcs_emit_txbuffer(card);
1516     spin_unlock(&card->lock);
1517 }
1518 
1519 /*
1520  * Packet transmit function called by network stack
1521  */
1522 static int
1523 __lcs_start_xmit(struct lcs_card *card, struct sk_buff *skb,
1524          struct net_device *dev)
1525 {
1526     struct lcs_header *header;
1527     int rc = NETDEV_TX_OK;
1528 
1529     LCS_DBF_TEXT(5, trace, "hardxmit");
1530     if (skb == NULL) {
1531         card->stats.tx_dropped++;
1532         card->stats.tx_errors++;
1533         return NETDEV_TX_OK;
1534     }
1535     if (card->state != DEV_STATE_UP) {
1536         dev_kfree_skb(skb);
1537         card->stats.tx_dropped++;
1538         card->stats.tx_errors++;
1539         card->stats.tx_carrier_errors++;
1540         return NETDEV_TX_OK;
1541     }
1542     if (skb->protocol == htons(ETH_P_IPV6)) {
1543         dev_kfree_skb(skb);
1544         return NETDEV_TX_OK;
1545     }
1546     netif_stop_queue(card->dev);
1547     spin_lock(&card->lock);
1548     if (card->tx_buffer != NULL &&
1549         card->tx_buffer->count + sizeof(struct lcs_header) +
1550         skb->len + sizeof(u16) > LCS_IOBUFFERSIZE)
1551         /* skb too big for current tx buffer. */
1552         __lcs_emit_txbuffer(card);
1553     if (card->tx_buffer == NULL) {
1554         /* Get new tx buffer */
1555         card->tx_buffer = lcs_get_buffer(&card->write);
1556         if (card->tx_buffer == NULL) {
1557             card->stats.tx_dropped++;
1558             rc = NETDEV_TX_BUSY;
1559             goto out;
1560         }
1561         card->tx_buffer->callback = lcs_txbuffer_cb;
1562         card->tx_buffer->count = 0;
1563     }
1564     header = (struct lcs_header *)
1565         (card->tx_buffer->data + card->tx_buffer->count);
1566     card->tx_buffer->count += skb->len + sizeof(struct lcs_header);
1567     header->offset = card->tx_buffer->count;
1568     header->type = card->lan_type;
1569     header->slot = card->portno;
1570     skb_copy_from_linear_data(skb, header + 1, skb->len);
1571     spin_unlock(&card->lock);
1572     card->stats.tx_bytes += skb->len;
1573     card->stats.tx_packets++;
1574     dev_kfree_skb(skb);
1575     netif_wake_queue(card->dev);
1576     spin_lock(&card->lock);
1577     if (card->tx_emitted <= 0 && card->tx_buffer != NULL)
1578         /* If this is the first tx buffer emit it immediately. */
1579         __lcs_emit_txbuffer(card);
1580 out:
1581     spin_unlock(&card->lock);
1582     return rc;
1583 }
1584 
1585 static int
1586 lcs_start_xmit(struct sk_buff *skb, struct net_device *dev)
1587 {
1588     struct lcs_card *card;
1589     int rc;
1590 
1591     LCS_DBF_TEXT(5, trace, "pktxmit");
1592     card = (struct lcs_card *) dev->ml_priv;
1593     rc = __lcs_start_xmit(card, skb, dev);
1594     return rc;
1595 }
1596 
1597 /*
1598  * send startlan and lanstat command to make LCS device ready
1599  */
1600 static int
1601 lcs_startlan_auto(struct lcs_card *card)
1602 {
1603     int rc;
1604 
1605     LCS_DBF_TEXT(2, trace, "strtauto");
1606 #ifdef CONFIG_ETHERNET
1607     card->lan_type = LCS_FRAME_TYPE_ENET;
1608     rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP);
1609     if (rc == 0)
1610         return 0;
1611 
1612 #endif
1613 #ifdef CONFIG_FDDI
1614     card->lan_type = LCS_FRAME_TYPE_FDDI;
1615     rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP);
1616     if (rc == 0)
1617         return 0;
1618 #endif
1619     return -EIO;
1620 }
1621 
1622 static int
1623 lcs_startlan(struct lcs_card *card)
1624 {
1625     int rc, i;
1626 
1627     LCS_DBF_TEXT(2, trace, "startlan");
1628     rc = 0;
1629     if (card->portno != LCS_INVALID_PORT_NO) {
1630         if (card->lan_type == LCS_FRAME_TYPE_AUTO)
1631             rc = lcs_startlan_auto(card);
1632         else
1633             rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP);
1634     } else {
1635                 for (i = 0; i <= 16; i++) {
1636                         card->portno = i;
1637                         if (card->lan_type != LCS_FRAME_TYPE_AUTO)
1638                                 rc = lcs_send_startlan(card,
1639                                                        LCS_INITIATOR_TCPIP);
1640                         else
1641                                 /* autodetecting lan type */
1642                                 rc = lcs_startlan_auto(card);
1643                         if (rc == 0)
1644                                 break;
1645                 }
1646         }
1647     if (rc == 0)
1648         return lcs_send_lanstat(card);
1649     return rc;
1650 }
1651 
1652 /*
1653  * LCS detect function
1654  * setup channels and make them I/O ready
1655  */
1656 static int
1657 lcs_detect(struct lcs_card *card)
1658 {
1659     int rc = 0;
1660 
1661     LCS_DBF_TEXT(2, setup, "lcsdetct");
1662     /* start/reset card */
1663     if (card->dev)
1664         netif_stop_queue(card->dev);
1665     rc = lcs_stop_channels(card);
1666     if (rc == 0) {
1667         rc = lcs_start_channels(card);
1668         if (rc == 0) {
1669             rc = lcs_send_startup(card, LCS_INITIATOR_TCPIP);
1670             if (rc == 0)
1671                 rc = lcs_startlan(card);
1672         }
1673     }
1674     if (rc == 0) {
1675         card->state = DEV_STATE_UP;
1676     } else {
1677         card->state = DEV_STATE_DOWN;
1678         card->write.state = LCS_CH_STATE_INIT;
1679         card->read.state =  LCS_CH_STATE_INIT;
1680     }
1681     return rc;
1682 }
1683 
1684 /*
1685  * LCS Stop card
1686  */
1687 static int
1688 lcs_stopcard(struct lcs_card *card)
1689 {
1690     int rc;
1691 
1692     LCS_DBF_TEXT(3, setup, "stopcard");
1693 
1694     if (card->read.state != LCS_CH_STATE_STOPPED &&
1695         card->write.state != LCS_CH_STATE_STOPPED &&
1696         card->read.state != LCS_CH_STATE_ERROR &&
1697         card->write.state != LCS_CH_STATE_ERROR &&
1698         card->state == DEV_STATE_UP) {
1699         lcs_clear_multicast_list(card);
1700         rc = lcs_send_stoplan(card,LCS_INITIATOR_TCPIP);
1701         rc = lcs_send_shutdown(card);
1702     }
1703     rc = lcs_stop_channels(card);
1704     card->state = DEV_STATE_DOWN;
1705 
1706     return rc;
1707 }
1708 
1709 /*
1710  * Kernel Thread helper functions for LGW initiated commands
1711  */
1712 static void
1713 lcs_start_kernel_thread(struct work_struct *work)
1714 {
1715     struct lcs_card *card = container_of(work, struct lcs_card, kernel_thread_starter);
1716     LCS_DBF_TEXT(5, trace, "krnthrd");
1717     if (lcs_do_start_thread(card, LCS_RECOVERY_THREAD))
1718         kthread_run(lcs_recovery, card, "lcs_recover");
1719 #ifdef CONFIG_IP_MULTICAST
1720     if (lcs_do_start_thread(card, LCS_SET_MC_THREAD))
1721         kthread_run(lcs_register_mc_addresses, card, "regipm");
1722 #endif
1723 }
1724 
1725 /*
1726  * Process control frames.
1727  */
1728 static void
1729 lcs_get_control(struct lcs_card *card, struct lcs_cmd *cmd)
1730 {
1731     LCS_DBF_TEXT(5, trace, "getctrl");
1732     if (cmd->initiator == LCS_INITIATOR_LGW) {
1733         switch(cmd->cmd_code) {
1734         case LCS_CMD_STARTUP:
1735         case LCS_CMD_STARTLAN:
1736             lcs_schedule_recovery(card);
1737             break;
1738         case LCS_CMD_STOPLAN:
1739             if (card->dev) {
1740                 pr_warn("Stoplan for %s initiated by LGW\n",
1741                     card->dev->name);
1742                 netif_carrier_off(card->dev);
1743             }
1744             break;
1745         default:
1746             LCS_DBF_TEXT(5, trace, "noLGWcmd");
1747             break;
1748         }
1749     } else
1750         lcs_notify_lancmd_waiters(card, cmd);
1751 }
1752 
1753 /*
1754  * Unpack network packet.
1755  */
1756 static void
1757 lcs_get_skb(struct lcs_card *card, char *skb_data, unsigned int skb_len)
1758 {
1759     struct sk_buff *skb;
1760 
1761     LCS_DBF_TEXT(5, trace, "getskb");
1762     if (card->dev == NULL ||
1763         card->state != DEV_STATE_UP)
1764         /* The card isn't up. Ignore the packet. */
1765         return;
1766 
1767     skb = dev_alloc_skb(skb_len);
1768     if (skb == NULL) {
1769         dev_err(&card->dev->dev,
1770             " Allocating a socket buffer to interface %s failed\n",
1771               card->dev->name);
1772         card->stats.rx_dropped++;
1773         return;
1774     }
1775     skb_put_data(skb, skb_data, skb_len);
1776     skb->protocol = card->lan_type_trans(skb, card->dev);
1777     card->stats.rx_bytes += skb_len;
1778     card->stats.rx_packets++;
1779     if (skb->protocol == htons(ETH_P_802_2))
1780         *((__u32 *)skb->cb) = ++card->pkt_seq;
1781     netif_rx(skb);
1782 }
1783 
1784 /*
1785  * LCS main routine to get packets and lancmd replies from the buffers
1786  */
1787 static void
1788 lcs_get_frames_cb(struct lcs_channel *channel, struct lcs_buffer *buffer)
1789 {
1790     struct lcs_card *card;
1791     struct lcs_header *lcs_hdr;
1792     __u16 offset;
1793 
1794     LCS_DBF_TEXT(5, trace, "lcsgtpkt");
1795     lcs_hdr = (struct lcs_header *) buffer->data;
1796     if (lcs_hdr->offset == LCS_ILLEGAL_OFFSET) {
1797         LCS_DBF_TEXT(4, trace, "-eiogpkt");
1798         return;
1799     }
1800     card = container_of(channel, struct lcs_card, read);
1801     offset = 0;
1802     while (lcs_hdr->offset != 0) {
1803         if (lcs_hdr->offset <= 0 ||
1804             lcs_hdr->offset > LCS_IOBUFFERSIZE ||
1805             lcs_hdr->offset < offset) {
1806             /* Offset invalid. */
1807             card->stats.rx_length_errors++;
1808             card->stats.rx_errors++;
1809             return;
1810         }
1811         /* What kind of frame is it? */
1812         if (lcs_hdr->type == LCS_FRAME_TYPE_CONTROL) {
1813             /* Control frame. */
1814             lcs_get_control(card, (struct lcs_cmd *) lcs_hdr);
1815         } else if (lcs_hdr->type == LCS_FRAME_TYPE_ENET ||
1816                lcs_hdr->type == LCS_FRAME_TYPE_TR ||
1817                lcs_hdr->type == LCS_FRAME_TYPE_FDDI) {
1818             /* Normal network packet. */
1819             lcs_get_skb(card, (char *)(lcs_hdr + 1),
1820                     lcs_hdr->offset - offset -
1821                     sizeof(struct lcs_header));
1822         } else {
1823             /* Unknown frame type. */
1824             ; // FIXME: error message ?
1825         }
1826         /* Proceed to next frame. */
1827         offset = lcs_hdr->offset;
1828         lcs_hdr->offset = LCS_ILLEGAL_OFFSET;
1829         lcs_hdr = (struct lcs_header *) (buffer->data + offset);
1830     }
1831     /* The buffer is now empty. Make it ready again. */
1832     lcs_ready_buffer(&card->read, buffer);
1833 }
1834 
1835 /*
1836  * get network statistics for ifconfig and other user programs
1837  */
1838 static struct net_device_stats *
1839 lcs_getstats(struct net_device *dev)
1840 {
1841     struct lcs_card *card;
1842 
1843     LCS_DBF_TEXT(4, trace, "netstats");
1844     card = (struct lcs_card *) dev->ml_priv;
1845     return &card->stats;
1846 }
1847 
1848 /*
1849  * stop lcs device
1850  * This function will be called by user doing ifconfig xxx down
1851  */
1852 static int
1853 lcs_stop_device(struct net_device *dev)
1854 {
1855     struct lcs_card *card;
1856     int rc;
1857 
1858     LCS_DBF_TEXT(2, trace, "stopdev");
1859     card   = (struct lcs_card *) dev->ml_priv;
1860     netif_carrier_off(dev);
1861     netif_tx_disable(dev);
1862     dev->flags &= ~IFF_UP;
1863     wait_event(card->write.wait_q,
1864         (card->write.state != LCS_CH_STATE_RUNNING));
1865     rc = lcs_stopcard(card);
1866     if (rc)
1867         dev_err(&card->dev->dev,
1868             " Shutting down the LCS device failed\n");
1869     return rc;
1870 }
1871 
1872 /*
1873  * start lcs device and make it runnable
1874  * This function will be called by user doing ifconfig xxx up
1875  */
1876 static int
1877 lcs_open_device(struct net_device *dev)
1878 {
1879     struct lcs_card *card;
1880     int rc;
1881 
1882     LCS_DBF_TEXT(2, trace, "opendev");
1883     card = (struct lcs_card *) dev->ml_priv;
1884     /* initialize statistics */
1885     rc = lcs_detect(card);
1886     if (rc) {
1887         pr_err("Error in opening device!\n");
1888 
1889     } else {
1890         dev->flags |= IFF_UP;
1891         netif_carrier_on(dev);
1892         netif_wake_queue(dev);
1893         card->state = DEV_STATE_UP;
1894     }
1895     return rc;
1896 }
1897 
1898 /*
1899  * show function for portno called by cat or similar things
1900  */
1901 static ssize_t
1902 lcs_portno_show (struct device *dev, struct device_attribute *attr, char *buf)
1903 {
1904         struct lcs_card *card;
1905 
1906     card = dev_get_drvdata(dev);
1907 
1908         if (!card)
1909                 return 0;
1910 
1911         return sprintf(buf, "%d\n", card->portno);
1912 }
1913 
1914 /*
1915  * store the value which is piped to file portno
1916  */
1917 static ssize_t
1918 lcs_portno_store (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1919 {
1920         struct lcs_card *card;
1921     int rc;
1922     s16 value;
1923 
1924     card = dev_get_drvdata(dev);
1925 
1926         if (!card)
1927                 return 0;
1928 
1929     rc = kstrtos16(buf, 0, &value);
1930     if (rc)
1931         return -EINVAL;
1932         /* TODO: sanity checks */
1933         card->portno = value;
1934     if (card->dev)
1935         card->dev->dev_port = card->portno;
1936 
1937         return count;
1938 
1939 }
1940 
1941 static DEVICE_ATTR(portno, 0644, lcs_portno_show, lcs_portno_store);
1942 
1943 static const char *lcs_type[] = {
1944     "not a channel",
1945     "2216 parallel",
1946     "2216 channel",
1947     "OSA LCS card",
1948     "unknown channel type",
1949     "unsupported channel type",
1950 };
1951 
1952 static ssize_t
1953 lcs_type_show(struct device *dev, struct device_attribute *attr, char *buf)
1954 {
1955     struct ccwgroup_device *cgdev;
1956 
1957     cgdev = to_ccwgroupdev(dev);
1958     if (!cgdev)
1959         return -ENODEV;
1960 
1961     return sprintf(buf, "%s\n", lcs_type[cgdev->cdev[0]->id.driver_info]);
1962 }
1963 
1964 static DEVICE_ATTR(type, 0444, lcs_type_show, NULL);
1965 
1966 static ssize_t
1967 lcs_timeout_show(struct device *dev, struct device_attribute *attr, char *buf)
1968 {
1969     struct lcs_card *card;
1970 
1971     card = dev_get_drvdata(dev);
1972 
1973     return card ? sprintf(buf, "%u\n", card->lancmd_timeout) : 0;
1974 }
1975 
1976 static ssize_t
1977 lcs_timeout_store (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1978 {
1979         struct lcs_card *card;
1980     unsigned int value;
1981     int rc;
1982 
1983     card = dev_get_drvdata(dev);
1984 
1985         if (!card)
1986                 return 0;
1987 
1988     rc = kstrtouint(buf, 0, &value);
1989     if (rc)
1990         return -EINVAL;
1991         /* TODO: sanity checks */
1992         card->lancmd_timeout = value;
1993 
1994         return count;
1995 
1996 }
1997 
1998 static DEVICE_ATTR(lancmd_timeout, 0644, lcs_timeout_show, lcs_timeout_store);
1999 
2000 static ssize_t
2001 lcs_dev_recover_store(struct device *dev, struct device_attribute *attr,
2002               const char *buf, size_t count)
2003 {
2004     struct lcs_card *card = dev_get_drvdata(dev);
2005     char *tmp;
2006     int i;
2007 
2008     if (!card)
2009         return -EINVAL;
2010     if (card->state != DEV_STATE_UP)
2011         return -EPERM;
2012     i = simple_strtoul(buf, &tmp, 16);
2013     if (i == 1)
2014         lcs_schedule_recovery(card);
2015     return count;
2016 }
2017 
2018 static DEVICE_ATTR(recover, 0200, NULL, lcs_dev_recover_store);
2019 
2020 static struct attribute * lcs_attrs[] = {
2021     &dev_attr_portno.attr,
2022     &dev_attr_type.attr,
2023     &dev_attr_lancmd_timeout.attr,
2024     &dev_attr_recover.attr,
2025     NULL,
2026 };
2027 static struct attribute_group lcs_attr_group = {
2028     .attrs = lcs_attrs,
2029 };
2030 static const struct attribute_group *lcs_attr_groups[] = {
2031     &lcs_attr_group,
2032     NULL,
2033 };
2034 static const struct device_type lcs_devtype = {
2035     .name = "lcs",
2036     .groups = lcs_attr_groups,
2037 };
2038 
2039 /*
2040  * lcs_probe_device is called on establishing a new ccwgroup_device.
2041  */
2042 static int
2043 lcs_probe_device(struct ccwgroup_device *ccwgdev)
2044 {
2045     struct lcs_card *card;
2046 
2047     if (!get_device(&ccwgdev->dev))
2048         return -ENODEV;
2049 
2050     LCS_DBF_TEXT(2, setup, "add_dev");
2051         card = lcs_alloc_card();
2052         if (!card) {
2053         LCS_DBF_TEXT_(2, setup, "  rc%d", -ENOMEM);
2054         put_device(&ccwgdev->dev);
2055                 return -ENOMEM;
2056         }
2057     dev_set_drvdata(&ccwgdev->dev, card);
2058     ccwgdev->cdev[0]->handler = lcs_irq;
2059     ccwgdev->cdev[1]->handler = lcs_irq;
2060     card->gdev = ccwgdev;
2061     INIT_WORK(&card->kernel_thread_starter, lcs_start_kernel_thread);
2062     card->thread_start_mask = 0;
2063     card->thread_allowed_mask = 0;
2064     card->thread_running_mask = 0;
2065     ccwgdev->dev.type = &lcs_devtype;
2066 
2067     return 0;
2068 }
2069 
2070 static int
2071 lcs_register_netdev(struct ccwgroup_device *ccwgdev)
2072 {
2073     struct lcs_card *card;
2074 
2075     LCS_DBF_TEXT(2, setup, "regnetdv");
2076     card = dev_get_drvdata(&ccwgdev->dev);
2077     if (card->dev->reg_state != NETREG_UNINITIALIZED)
2078         return 0;
2079     SET_NETDEV_DEV(card->dev, &ccwgdev->dev);
2080     return register_netdev(card->dev);
2081 }
2082 
2083 /*
2084  * lcs_new_device will be called by setting the group device online.
2085  */
2086 static const struct net_device_ops lcs_netdev_ops = {
2087     .ndo_open       = lcs_open_device,
2088     .ndo_stop       = lcs_stop_device,
2089     .ndo_get_stats      = lcs_getstats,
2090     .ndo_start_xmit     = lcs_start_xmit,
2091 };
2092 
2093 static const struct net_device_ops lcs_mc_netdev_ops = {
2094     .ndo_open       = lcs_open_device,
2095     .ndo_stop       = lcs_stop_device,
2096     .ndo_get_stats      = lcs_getstats,
2097     .ndo_start_xmit     = lcs_start_xmit,
2098     .ndo_set_rx_mode    = lcs_set_multicast_list,
2099 };
2100 
2101 static int
2102 lcs_new_device(struct ccwgroup_device *ccwgdev)
2103 {
2104     struct  lcs_card *card;
2105     struct net_device *dev=NULL;
2106     enum lcs_dev_states recover_state;
2107     int rc;
2108 
2109     card = dev_get_drvdata(&ccwgdev->dev);
2110     if (!card)
2111         return -ENODEV;
2112 
2113     LCS_DBF_TEXT(2, setup, "newdev");
2114     LCS_DBF_HEX(3, setup, &card, sizeof(void*));
2115     card->read.ccwdev  = ccwgdev->cdev[0];
2116     card->write.ccwdev = ccwgdev->cdev[1];
2117 
2118     recover_state = card->state;
2119     rc = ccw_device_set_online(card->read.ccwdev);
2120     if (rc)
2121         goto out_err;
2122     rc = ccw_device_set_online(card->write.ccwdev);
2123     if (rc)
2124         goto out_werr;
2125 
2126     LCS_DBF_TEXT(3, setup, "lcsnewdv");
2127 
2128     lcs_setup_card(card);
2129     rc = lcs_detect(card);
2130     if (rc) {
2131         LCS_DBF_TEXT(2, setup, "dtctfail");
2132         dev_err(&ccwgdev->dev,
2133             "Detecting a network adapter for LCS devices"
2134             " failed with rc=%d (0x%x)\n", rc, rc);
2135         lcs_stopcard(card);
2136         goto out;
2137     }
2138     if (card->dev) {
2139         LCS_DBF_TEXT(2, setup, "samedev");
2140         LCS_DBF_HEX(3, setup, &card, sizeof(void*));
2141         goto netdev_out;
2142     }
2143     switch (card->lan_type) {
2144 #ifdef CONFIG_ETHERNET
2145     case LCS_FRAME_TYPE_ENET:
2146         card->lan_type_trans = eth_type_trans;
2147         dev = alloc_etherdev(0);
2148         break;
2149 #endif
2150 #ifdef CONFIG_FDDI
2151     case LCS_FRAME_TYPE_FDDI:
2152         card->lan_type_trans = fddi_type_trans;
2153         dev = alloc_fddidev(0);
2154         break;
2155 #endif
2156     default:
2157         LCS_DBF_TEXT(3, setup, "errinit");
2158         pr_err(" Initialization failed\n");
2159         goto out;
2160     }
2161     if (!dev)
2162         goto out;
2163     card->dev = dev;
2164     card->dev->ml_priv = card;
2165     card->dev->netdev_ops = &lcs_netdev_ops;
2166     card->dev->dev_port = card->portno;
2167     eth_hw_addr_set(card->dev, card->mac);
2168 #ifdef CONFIG_IP_MULTICAST
2169     if (!lcs_check_multicast_support(card))
2170         card->dev->netdev_ops = &lcs_mc_netdev_ops;
2171 #endif
2172 netdev_out:
2173     lcs_set_allowed_threads(card,0xffffffff);
2174     if (recover_state == DEV_STATE_RECOVER) {
2175         lcs_set_multicast_list(card->dev);
2176         card->dev->flags |= IFF_UP;
2177         netif_carrier_on(card->dev);
2178         netif_wake_queue(card->dev);
2179         card->state = DEV_STATE_UP;
2180     } else {
2181         lcs_stopcard(card);
2182     }
2183 
2184     if (lcs_register_netdev(ccwgdev) != 0)
2185         goto out;
2186 
2187     /* Print out supported assists: IPv6 */
2188     pr_info("LCS device %s %s IPv6 support\n", card->dev->name,
2189         (card->ip_assists_supported & LCS_IPASS_IPV6_SUPPORT) ?
2190         "with" : "without");
2191     /* Print out supported assist: Multicast */
2192     pr_info("LCS device %s %s Multicast support\n", card->dev->name,
2193         (card->ip_assists_supported & LCS_IPASS_MULTICAST_SUPPORT) ?
2194         "with" : "without");
2195     return 0;
2196 out:
2197 
2198     ccw_device_set_offline(card->write.ccwdev);
2199 out_werr:
2200     ccw_device_set_offline(card->read.ccwdev);
2201 out_err:
2202     return -ENODEV;
2203 }
2204 
2205 /*
2206  * lcs_shutdown_device, called when setting the group device offline.
2207  */
2208 static int
2209 __lcs_shutdown_device(struct ccwgroup_device *ccwgdev, int recovery_mode)
2210 {
2211     struct lcs_card *card;
2212     enum lcs_dev_states recover_state;
2213     int ret = 0, ret2 = 0, ret3 = 0;
2214 
2215     LCS_DBF_TEXT(3, setup, "shtdndev");
2216     card = dev_get_drvdata(&ccwgdev->dev);
2217     if (!card)
2218         return -ENODEV;
2219     if (recovery_mode == 0) {
2220         lcs_set_allowed_threads(card, 0);
2221         if (lcs_wait_for_threads(card, LCS_SET_MC_THREAD))
2222             return -ERESTARTSYS;
2223     }
2224     LCS_DBF_HEX(3, setup, &card, sizeof(void*));
2225     recover_state = card->state;
2226 
2227     ret = lcs_stop_device(card->dev);
2228     ret2 = ccw_device_set_offline(card->read.ccwdev);
2229     ret3 = ccw_device_set_offline(card->write.ccwdev);
2230     if (!ret)
2231         ret = (ret2) ? ret2 : ret3;
2232     if (ret)
2233         LCS_DBF_TEXT_(3, setup, "1err:%d", ret);
2234     if (recover_state == DEV_STATE_UP) {
2235         card->state = DEV_STATE_RECOVER;
2236     }
2237     return 0;
2238 }
2239 
2240 static int
2241 lcs_shutdown_device(struct ccwgroup_device *ccwgdev)
2242 {
2243     return __lcs_shutdown_device(ccwgdev, 0);
2244 }
2245 
2246 /*
2247  * drive lcs recovery after startup and startlan initiated by Lan Gateway
2248  */
2249 static int
2250 lcs_recovery(void *ptr)
2251 {
2252     struct lcs_card *card;
2253     struct ccwgroup_device *gdev;
2254         int rc;
2255 
2256     card = (struct lcs_card *) ptr;
2257 
2258     LCS_DBF_TEXT(4, trace, "recover1");
2259     if (!lcs_do_run_thread(card, LCS_RECOVERY_THREAD))
2260         return 0;
2261     LCS_DBF_TEXT(4, trace, "recover2");
2262     gdev = card->gdev;
2263     dev_warn(&gdev->dev,
2264         "A recovery process has been started for the LCS device\n");
2265     rc = __lcs_shutdown_device(gdev, 1);
2266     rc = lcs_new_device(gdev);
2267     if (!rc)
2268         pr_info("Device %s successfully recovered!\n",
2269             card->dev->name);
2270     else
2271         pr_info("Device %s could not be recovered!\n",
2272             card->dev->name);
2273     lcs_clear_thread_running_bit(card, LCS_RECOVERY_THREAD);
2274     return 0;
2275 }
2276 
2277 /*
2278  * lcs_remove_device, free buffers and card
2279  */
2280 static void
2281 lcs_remove_device(struct ccwgroup_device *ccwgdev)
2282 {
2283     struct lcs_card *card;
2284 
2285     card = dev_get_drvdata(&ccwgdev->dev);
2286     if (!card)
2287         return;
2288 
2289     LCS_DBF_TEXT(3, setup, "remdev");
2290     LCS_DBF_HEX(3, setup, &card, sizeof(void*));
2291     if (ccwgdev->state == CCWGROUP_ONLINE) {
2292         lcs_shutdown_device(ccwgdev);
2293     }
2294     if (card->dev)
2295         unregister_netdev(card->dev);
2296     lcs_cleanup_card(card);
2297     lcs_free_card(card);
2298     dev_set_drvdata(&ccwgdev->dev, NULL);
2299     put_device(&ccwgdev->dev);
2300 }
2301 
2302 static struct ccw_device_id lcs_ids[] = {
2303     {CCW_DEVICE(0x3088, 0x08), .driver_info = lcs_channel_type_parallel},
2304     {CCW_DEVICE(0x3088, 0x1f), .driver_info = lcs_channel_type_2216},
2305     {CCW_DEVICE(0x3088, 0x60), .driver_info = lcs_channel_type_osa2},
2306     {},
2307 };
2308 MODULE_DEVICE_TABLE(ccw, lcs_ids);
2309 
2310 static struct ccw_driver lcs_ccw_driver = {
2311     .driver = {
2312         .owner  = THIS_MODULE,
2313         .name   = "lcs",
2314     },
2315     .ids    = lcs_ids,
2316     .probe  = ccwgroup_probe_ccwdev,
2317     .remove = ccwgroup_remove_ccwdev,
2318     .int_class = IRQIO_LCS,
2319 };
2320 
2321 /*
2322  * LCS ccwgroup driver registration
2323  */
2324 static struct ccwgroup_driver lcs_group_driver = {
2325     .driver = {
2326         .owner  = THIS_MODULE,
2327         .name   = "lcs",
2328     },
2329     .ccw_driver  = &lcs_ccw_driver,
2330     .setup       = lcs_probe_device,
2331     .remove      = lcs_remove_device,
2332     .set_online  = lcs_new_device,
2333     .set_offline = lcs_shutdown_device,
2334 };
2335 
2336 static ssize_t group_store(struct device_driver *ddrv, const char *buf,
2337                size_t count)
2338 {
2339     int err;
2340     err = ccwgroup_create_dev(lcs_root_dev, &lcs_group_driver, 2, buf);
2341     return err ? err : count;
2342 }
2343 static DRIVER_ATTR_WO(group);
2344 
2345 static struct attribute *lcs_drv_attrs[] = {
2346     &driver_attr_group.attr,
2347     NULL,
2348 };
2349 static struct attribute_group lcs_drv_attr_group = {
2350     .attrs = lcs_drv_attrs,
2351 };
2352 static const struct attribute_group *lcs_drv_attr_groups[] = {
2353     &lcs_drv_attr_group,
2354     NULL,
2355 };
2356 
2357 /*
2358  *  LCS Module/Kernel initialization function
2359  */
2360 static int
2361 __init lcs_init_module(void)
2362 {
2363     int rc;
2364 
2365     pr_info("Loading %s\n", version);
2366     rc = lcs_register_debug_facility();
2367     LCS_DBF_TEXT(0, setup, "lcsinit");
2368     if (rc)
2369         goto out_err;
2370     lcs_root_dev = root_device_register("lcs");
2371     rc = PTR_ERR_OR_ZERO(lcs_root_dev);
2372     if (rc)
2373         goto register_err;
2374     rc = ccw_driver_register(&lcs_ccw_driver);
2375     if (rc)
2376         goto ccw_err;
2377     lcs_group_driver.driver.groups = lcs_drv_attr_groups;
2378     rc = ccwgroup_driver_register(&lcs_group_driver);
2379     if (rc)
2380         goto ccwgroup_err;
2381     return 0;
2382 
2383 ccwgroup_err:
2384     ccw_driver_unregister(&lcs_ccw_driver);
2385 ccw_err:
2386     root_device_unregister(lcs_root_dev);
2387 register_err:
2388     lcs_unregister_debug_facility();
2389 out_err:
2390     pr_err("Initializing the lcs device driver failed\n");
2391     return rc;
2392 }
2393 
2394 
2395 /*
2396  *  LCS module cleanup function
2397  */
2398 static void
2399 __exit lcs_cleanup_module(void)
2400 {
2401     pr_info("Terminating lcs module.\n");
2402     LCS_DBF_TEXT(0, trace, "cleanup");
2403     ccwgroup_driver_unregister(&lcs_group_driver);
2404     ccw_driver_unregister(&lcs_ccw_driver);
2405     root_device_unregister(lcs_root_dev);
2406     lcs_unregister_debug_facility();
2407 }
2408 
2409 module_init(lcs_init_module);
2410 module_exit(lcs_cleanup_module);
2411 
2412 MODULE_AUTHOR("Frank Pavlic <fpavlic@de.ibm.com>");
2413 MODULE_LICENSE("GPL");
2414
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!