drivers/s390/net/lcs.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  *  Linux for S/390 Lan Channel Station Network Driver
   4  *
   5  *  Copyright IBM Corp. 1999, 2009
   6  *  Author(s): Original Code written by
   7  *                      DJ Barrow <djbarrow@de.ibm.com,barrow_dj@yahoo.com>
   8  *             Rewritten by
   9  *                      Frank Pavlic <fpavlic@de.ibm.com> and
  10  *                      Martin Schwidefsky <schwidefsky@de.ibm.com>
  11  */
  12
  13 #define KMSG_COMPONENT          "lcs"
  14 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  15
  16 #include <linux/module.h>
  17 #include <linux/if.h>
  18 #include <linux/netdevice.h>
  19 #include <linux/etherdevice.h>
  20 #include <linux/fddidevice.h>
  21 #include <linux/inetdevice.h>
  22 #include <linux/in.h>
  23 #include <linux/igmp.h>
  24 #include <linux/delay.h>
  25 #include <linux/kthread.h>
  26 #include <linux/slab.h>
  27 #include <net/arp.h>
  28 #include <net/ip.h>
  29
  30 #include <asm/debug.h>
  31 #include <asm/idals.h>
  32 #include <asm/timex.h>
  33 #include <linux/device.h>
  34 #include <asm/ccwgroup.h>
  35
  36 #include "lcs.h"
  37
  38
  39 #if !defined(CONFIG_ETHERNET) && !defined(CONFIG_FDDI)
  40 #error Cannot compile lcs.c without some net devices switched on.
  41 #endif
  42
  43 /*
  44  * initialization string for output
  45  */
  46
  47 static char version[] __initdata = "LCS driver";
  48
  49 /*
  50   * the root device for lcs group devices
  51   */
  52 static struct device *lcs_root_dev;
  53
  54 /*
  55  * Some prototypes.
  56  */
  57 static void lcs_tasklet(unsigned long);
  58 static void lcs_start_kernel_thread(struct work_struct *);
  59 static void lcs_get_frames_cb(struct lcs_channel *, struct lcs_buffer *);
  60 #ifdef CONFIG_IP_MULTICAST
  61 static int lcs_send_delipm(struct lcs_card *, struct lcs_ipm_list *);
  62 #endif /* CONFIG_IP_MULTICAST */
  63 static int lcs_recovery(void *ptr);
  64
  65 /*
  66  * Debug Facility Stuff
  67  */
  68 static char debug_buffer[255];
  69 static debug_info_t *lcs_dbf_setup;
  70 static debug_info_t *lcs_dbf_trace;
  71
  72 /*
  73  *  LCS Debug Facility functions
  74  */
  75 static void
  76 lcs_unregister_debug_facility(void)
  77 {
  78         debug_unregister(lcs_dbf_setup);
  79         debug_unregister(lcs_dbf_trace);
  80 }
  81
  82 static int
  83 lcs_register_debug_facility(void)
  84 {
  85         lcs_dbf_setup = debug_register("lcs_setup", 2, 1, 8);
  86         lcs_dbf_trace = debug_register("lcs_trace", 4, 1, 8);
  87         if (lcs_dbf_setup == NULL || lcs_dbf_trace == NULL) {
  88                 pr_err("Not enough memory for debug facility.\n");
  89                 lcs_unregister_debug_facility();
  90                 return -ENOMEM;
  91         }
  92         debug_register_view(lcs_dbf_setup, &debug_hex_ascii_view);
  93         debug_set_level(lcs_dbf_setup, 2);
  94         debug_register_view(lcs_dbf_trace, &debug_hex_ascii_view);
  95         debug_set_level(lcs_dbf_trace, 2);
  96         return 0;
  97 }
  98
  99 /*
 100  * Allocate io buffers.
 101  */
 102 static int
 103 lcs_alloc_channel(struct lcs_channel *channel)
 104 {
 105         int cnt;
 106
 107         LCS_DBF_TEXT(2, setup, "ichalloc");
 108         for (cnt = 0; cnt < LCS_NUM_BUFFS; cnt++) {
 109                 /* alloc memory fo iobuffer */
 110                 channel->iob[cnt].data =
 111                         kzalloc(LCS_IOBUFFERSIZE, GFP_DMA | GFP_KERNEL);
 112                 if (channel->iob[cnt].data == NULL)
 113                         break;
 114                 channel->iob[cnt].state = LCS_BUF_STATE_EMPTY;
 115         }
 116         if (cnt < LCS_NUM_BUFFS) {
 117                 /* Not all io buffers could be allocated. */
 118                 LCS_DBF_TEXT(2, setup, "echalloc");
 119                 while (cnt-- > 0)
 120                         kfree(channel->iob[cnt].data);
 121                 return -ENOMEM;
 122         }
 123         return 0;
 124 }
 125
 126 /*
 127  * Free io buffers.
 128  */
 129 static void
 130 lcs_free_channel(struct lcs_channel *channel)
 131 {
 132         int cnt;
 133
 134         LCS_DBF_TEXT(2, setup, "ichfree");
 135         for (cnt = 0; cnt < LCS_NUM_BUFFS; cnt++) {
 136                 kfree(channel->iob[cnt].data);
 137                 channel->iob[cnt].data = NULL;
 138         }
 139 }
 140
 141 /*
 142  * Cleanup channel.
 143  */
 144 static void
 145 lcs_cleanup_channel(struct lcs_channel *channel)
 146 {
 147         LCS_DBF_TEXT(3, setup, "cleanch");
 148         /* Kill write channel tasklets. */
 149         tasklet_kill(&channel->irq_tasklet);
 150         /* Free channel buffers. */
 151         lcs_free_channel(channel);
 152 }
 153
 154 /*
 155  * LCS free memory for card and channels.
 156  */
 157 static void
 158 lcs_free_card(struct lcs_card *card)
 159 {
 160         LCS_DBF_TEXT(2, setup, "remcard");
 161         LCS_DBF_HEX(2, setup, &card, sizeof(void*));
 162         kfree(card);
 163 }
 164
 165 /*
 166  * LCS alloc memory for card and channels
 167  */
 168 static struct lcs_card *
 169 lcs_alloc_card(void)
 170 {
 171         struct lcs_card *card;
 172         int rc;
 173
 174         LCS_DBF_TEXT(2, setup, "alloclcs");
 175
 176         card = kzalloc(sizeof(struct lcs_card), GFP_KERNEL | GFP_DMA);
 177         if (card == NULL)
 178                 return NULL;
 179         card->lan_type = LCS_FRAME_TYPE_AUTO;
 180         card->pkt_seq = 0;
 181         card->lancmd_timeout = LCS_LANCMD_TIMEOUT_DEFAULT;
 182         /* Allocate io buffers for the read channel. */
 183         rc = lcs_alloc_channel(&card->read);
 184         if (rc){
 185                 LCS_DBF_TEXT(2, setup, "iccwerr");
 186                 lcs_free_card(card);
 187                 return NULL;
 188         }
 189         /* Allocate io buffers for the write channel. */
 190         rc = lcs_alloc_channel(&card->write);
 191         if (rc) {
 192                 LCS_DBF_TEXT(2, setup, "iccwerr");
 193                 lcs_cleanup_channel(&card->read);
 194                 lcs_free_card(card);
 195                 return NULL;
 196         }
 197
 198 #ifdef CONFIG_IP_MULTICAST
 199         INIT_LIST_HEAD(&card->ipm_list);
 200 #endif
 201         LCS_DBF_HEX(2, setup, &card, sizeof(void*));
 202         return card;
 203 }
 204
 205 /*
 206  * Setup read channel.
 207  */
 208 static void
 209 lcs_setup_read_ccws(struct lcs_card *card)
 210 {
 211         int cnt;
 212
 213         LCS_DBF_TEXT(2, setup, "ireadccw");
 214         /* Setup read ccws. */
 215         memset(card->read.ccws, 0, sizeof (struct ccw1) * (LCS_NUM_BUFFS + 1));
 216         for (cnt = 0; cnt < LCS_NUM_BUFFS; cnt++) {
 217                 card->read.ccws[cnt].cmd_code = LCS_CCW_READ;
 218                 card->read.ccws[cnt].count = LCS_IOBUFFERSIZE;
 219                 card->read.ccws[cnt].flags =
 220                         CCW_FLAG_CC | CCW_FLAG_SLI | CCW_FLAG_PCI;
 221                 /*
 222                  * Note: we have allocated the buffer with GFP_DMA, so
 223                  * we do not need to do set_normalized_cda.
 224                  */
 225                 card->read.ccws[cnt].cda =
 226                         (__u32)virt_to_phys(card->read.iob[cnt].data);
 227                 ((struct lcs_header *)
 228                  card->read.iob[cnt].data)->offset = LCS_ILLEGAL_OFFSET;
 229                 card->read.iob[cnt].callback = lcs_get_frames_cb;
 230                 card->read.iob[cnt].state = LCS_BUF_STATE_READY;
 231                 card->read.iob[cnt].count = LCS_IOBUFFERSIZE;
 232         }
 233         card->read.ccws[0].flags &= ~CCW_FLAG_PCI;
 234         card->read.ccws[LCS_NUM_BUFFS - 1].flags &= ~CCW_FLAG_PCI;
 235         card->read.ccws[LCS_NUM_BUFFS - 1].flags |= CCW_FLAG_SUSPEND;
 236         /* Last ccw is a tic (transfer in channel). */
 237         card->read.ccws[LCS_NUM_BUFFS].cmd_code = LCS_CCW_TRANSFER;
 238         card->read.ccws[LCS_NUM_BUFFS].cda =
 239                 (__u32)virt_to_phys(card->read.ccws);
 240         /* Setg initial state of the read channel. */
 241         card->read.state = LCS_CH_STATE_INIT;
 242
 243         card->read.io_idx = 0;
 244         card->read.buf_idx = 0;
 245 }
 246
 247 static void
 248 lcs_setup_read(struct lcs_card *card)
 249 {
 250         LCS_DBF_TEXT(3, setup, "initread");
 251
 252         lcs_setup_read_ccws(card);
 253         /* Initialize read channel tasklet. */
 254         card->read.irq_tasklet.data = (unsigned long) &card->read;
 255         card->read.irq_tasklet.func = lcs_tasklet;
 256         /* Initialize waitqueue. */
 257         init_waitqueue_head(&card->read.wait_q);
 258 }
 259
 260 /*
 261  * Setup write channel.
 262  */
 263 static void
 264 lcs_setup_write_ccws(struct lcs_card *card)
 265 {
 266         int cnt;
 267
 268         LCS_DBF_TEXT(3, setup, "iwritccw");
 269         /* Setup write ccws. */
 270         memset(card->write.ccws, 0, sizeof(struct ccw1) * (LCS_NUM_BUFFS + 1));
 271         for (cnt = 0; cnt < LCS_NUM_BUFFS; cnt++) {
 272                 card->write.ccws[cnt].cmd_code = LCS_CCW_WRITE;
 273                 card->write.ccws[cnt].count = 0;
 274                 card->write.ccws[cnt].flags =
 275                         CCW_FLAG_SUSPEND | CCW_FLAG_CC | CCW_FLAG_SLI;
 276                 /*
 277                  * Note: we have allocated the buffer with GFP_DMA, so
 278                  * we do not need to do set_normalized_cda.
 279                  */
 280                 card->write.ccws[cnt].cda =
 281                         (__u32)virt_to_phys(card->write.iob[cnt].data);
 282         }
 283         /* Last ccw is a tic (transfer in channel). */
 284         card->write.ccws[LCS_NUM_BUFFS].cmd_code = LCS_CCW_TRANSFER;
 285         card->write.ccws[LCS_NUM_BUFFS].cda =
 286                 (__u32)virt_to_phys(card->write.ccws);
 287         /* Set initial state of the write channel. */
 288         card->read.state = LCS_CH_STATE_INIT;
 289
 290         card->write.io_idx = 0;
 291         card->write.buf_idx = 0;
 292 }
 293
 294 static void
 295 lcs_setup_write(struct lcs_card *card)
 296 {
 297         LCS_DBF_TEXT(3, setup, "initwrit");
 298
 299         lcs_setup_write_ccws(card);
 300         /* Initialize write channel tasklet. */
 301         card->write.irq_tasklet.data = (unsigned long) &card->write;
 302         card->write.irq_tasklet.func = lcs_tasklet;
 303         /* Initialize waitqueue. */
 304         init_waitqueue_head(&card->write.wait_q);
 305 }
 306
 307 static void
 308 lcs_set_allowed_threads(struct lcs_card *card, unsigned long threads)
 309 {
 310         unsigned long flags;
 311
 312         spin_lock_irqsave(&card->mask_lock, flags);
 313         card->thread_allowed_mask = threads;
 314         spin_unlock_irqrestore(&card->mask_lock, flags);
 315         wake_up(&card->wait_q);
 316 }
 317 static int lcs_threads_running(struct lcs_card *card, unsigned long threads)
 318 {
 319         unsigned long flags;
 320         int rc = 0;
 321
 322         spin_lock_irqsave(&card->mask_lock, flags);
 323         rc = (card->thread_running_mask & threads);
 324         spin_unlock_irqrestore(&card->mask_lock, flags);
 325         return rc;
 326 }
 327
 328 static int
 329 lcs_wait_for_threads(struct lcs_card *card, unsigned long threads)
 330 {
 331         return wait_event_interruptible(card->wait_q,
 332                         lcs_threads_running(card, threads) == 0);
 333 }
 334
 335 static int lcs_set_thread_start_bit(struct lcs_card *card, unsigned long thread)
 336 {
 337         unsigned long flags;
 338
 339         spin_lock_irqsave(&card->mask_lock, flags);
 340         if ( !(card->thread_allowed_mask & thread) ||
 341               (card->thread_start_mask & thread) ) {
 342                 spin_unlock_irqrestore(&card->mask_lock, flags);
 343                 return -EPERM;
 344         }
 345         card->thread_start_mask |= thread;
 346         spin_unlock_irqrestore(&card->mask_lock, flags);
 347         return 0;
 348 }
 349
 350 static void
 351 lcs_clear_thread_running_bit(struct lcs_card *card, unsigned long thread)
 352 {
 353         unsigned long flags;
 354
 355         spin_lock_irqsave(&card->mask_lock, flags);
 356         card->thread_running_mask &= ~thread;
 357         spin_unlock_irqrestore(&card->mask_lock, flags);
 358         wake_up(&card->wait_q);
 359 }
 360
 361 static int __lcs_do_run_thread(struct lcs_card *card, unsigned long thread)
 362 {
 363         unsigned long flags;
 364         int rc = 0;
 365
 366         spin_lock_irqsave(&card->mask_lock, flags);
 367         if (card->thread_start_mask & thread){
 368                 if ((card->thread_allowed_mask & thread) &&
 369                     !(card->thread_running_mask & thread)){
 370                         rc = 1;
 371                         card->thread_start_mask &= ~thread;
 372                         card->thread_running_mask |= thread;
 373                 } else
 374                         rc = -EPERM;
 375         }
 376         spin_unlock_irqrestore(&card->mask_lock, flags);
 377         return rc;
 378 }
 379
 380 static int
 381 lcs_do_run_thread(struct lcs_card *card, unsigned long thread)
 382 {
 383         int rc = 0;
 384         wait_event(card->wait_q,
 385                    (rc = __lcs_do_run_thread(card, thread)) >= 0);
 386         return rc;
 387 }
 388
 389 static int
 390 lcs_do_start_thread(struct lcs_card *card, unsigned long thread)
 391 {
 392         unsigned long flags;
 393         int rc = 0;
 394
 395         spin_lock_irqsave(&card->mask_lock, flags);
 396         LCS_DBF_TEXT_(4, trace, "  %02x%02x%02x",
 397                         (u8) card->thread_start_mask,
 398                         (u8) card->thread_allowed_mask,
 399                         (u8) card->thread_running_mask);
 400         rc = (card->thread_start_mask & thread);
 401         spin_unlock_irqrestore(&card->mask_lock, flags);
 402         return rc;
 403 }
 404
 405 /*
 406  * Initialize channels,card and state machines.
 407  */
 408 static void
 409 lcs_setup_card(struct lcs_card *card)
 410 {
 411         LCS_DBF_TEXT(2, setup, "initcard");
 412         LCS_DBF_HEX(2, setup, &card, sizeof(void*));
 413
 414         lcs_setup_read(card);
 415         lcs_setup_write(card);
 416         /* Set cards initial state. */
 417         card->state = DEV_STATE_DOWN;
 418         card->tx_buffer = NULL;
 419         card->tx_emitted = 0;
 420
 421         init_waitqueue_head(&card->wait_q);
 422         spin_lock_init(&card->lock);
 423         spin_lock_init(&card->ipm_lock);
 424         spin_lock_init(&card->mask_lock);
 425 #ifdef CONFIG_IP_MULTICAST
 426         INIT_LIST_HEAD(&card->ipm_list);
 427 #endif
 428         INIT_LIST_HEAD(&card->lancmd_waiters);
 429 }
 430
 431 static void lcs_clear_multicast_list(struct lcs_card *card)
 432 {
 433 #ifdef  CONFIG_IP_MULTICAST
 434         struct lcs_ipm_list *ipm;
 435         unsigned long flags;
 436
 437         /* Free multicast list. */
 438         LCS_DBF_TEXT(3, setup, "clmclist");
 439         spin_lock_irqsave(&card->ipm_lock, flags);
 440         while (!list_empty(&card->ipm_list)){
 441                 ipm = list_entry(card->ipm_list.next,
 442                                  struct lcs_ipm_list, list);
 443                 list_del(&ipm->list);
 444                 if (ipm->ipm_state != LCS_IPM_STATE_SET_REQUIRED){
 445                         spin_unlock_irqrestore(&card->ipm_lock, flags);
 446                         lcs_send_delipm(card, ipm);
 447                         spin_lock_irqsave(&card->ipm_lock, flags);
 448                 }
 449                 kfree(ipm);
 450         }
 451         spin_unlock_irqrestore(&card->ipm_lock, flags);
 452 #endif
 453 }
 454
 455 /*
 456  * Cleanup channels,card and state machines.
 457  */
 458 static void
 459 lcs_cleanup_card(struct lcs_card *card)
 460 {
 461
 462         LCS_DBF_TEXT(3, setup, "cleancrd");
 463         LCS_DBF_HEX(2,setup,&card,sizeof(void*));
 464
 465         if (card->dev != NULL)
 466                 free_netdev(card->dev);
 467         /* Cleanup channels. */
 468         lcs_cleanup_channel(&card->write);
 469         lcs_cleanup_channel(&card->read);
 470 }
 471
 472 /*
 473  * Start channel.
 474  */
 475 static int
 476 lcs_start_channel(struct lcs_channel *channel)
 477 {
 478         unsigned long flags;
 479         int rc;
 480
 481         LCS_DBF_TEXT_(4, trace,"ssch%s", dev_name(&channel->ccwdev->dev));
 482         spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
 483         rc = ccw_device_start(channel->ccwdev,
 484                               channel->ccws + channel->io_idx, 0, 0,
 485                               DOIO_DENY_PREFETCH | DOIO_ALLOW_SUSPEND);
 486         if (rc == 0)
 487                 channel->state = LCS_CH_STATE_RUNNING;
 488         spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
 489         if (rc) {
 490                 LCS_DBF_TEXT_(4,trace,"essh%s",
 491                               dev_name(&channel->ccwdev->dev));
 492                 dev_err(&channel->ccwdev->dev,
 493                         "Starting an LCS device resulted in an error,"
 494                         " rc=%d!\n", rc);
 495         }
 496         return rc;
 497 }
 498
 499 static int
 500 lcs_clear_channel(struct lcs_channel *channel)
 501 {
 502         unsigned long flags;
 503         int rc;
 504
 505         LCS_DBF_TEXT(4,trace,"clearch");
 506         LCS_DBF_TEXT_(4, trace, "%s", dev_name(&channel->ccwdev->dev));
 507         spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
 508         rc = ccw_device_clear(channel->ccwdev, 0);
 509         spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
 510         if (rc) {
 511                 LCS_DBF_TEXT_(4, trace, "ecsc%s",
 512                               dev_name(&channel->ccwdev->dev));
 513                 return rc;
 514         }
 515         wait_event(channel->wait_q, (channel->state == LCS_CH_STATE_CLEARED));
 516         channel->state = LCS_CH_STATE_STOPPED;
 517         return rc;
 518 }
 519
 520
 521 /*
 522  * Stop channel.
 523  */
 524 static int
 525 lcs_stop_channel(struct lcs_channel *channel)
 526 {
 527         unsigned long flags;
 528         int rc;
 529
 530         if (channel->state == LCS_CH_STATE_STOPPED)
 531                 return 0;
 532         LCS_DBF_TEXT(4,trace,"haltsch");
 533         LCS_DBF_TEXT_(4, trace, "%s", dev_name(&channel->ccwdev->dev));
 534         channel->state = LCS_CH_STATE_INIT;
 535         spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
 536         rc = ccw_device_halt(channel->ccwdev, 0);
 537         spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
 538         if (rc) {
 539                 LCS_DBF_TEXT_(4, trace, "ehsc%s",
 540                               dev_name(&channel->ccwdev->dev));
 541                 return rc;
 542         }
 543         /* Asynchronous halt initialted. Wait for its completion. */
 544         wait_event(channel->wait_q, (channel->state == LCS_CH_STATE_HALTED));
 545         lcs_clear_channel(channel);
 546         return 0;
 547 }
 548
 549 /*
 550  * start read and write channel
 551  */
 552 static int
 553 lcs_start_channels(struct lcs_card *card)
 554 {
 555         int rc;
 556
 557         LCS_DBF_TEXT(2, trace, "chstart");
 558         /* start read channel */
 559         rc = lcs_start_channel(&card->read);
 560         if (rc)
 561                 return rc;
 562         /* start write channel */
 563         rc = lcs_start_channel(&card->write);
 564         if (rc)
 565                 lcs_stop_channel(&card->read);
 566         return rc;
 567 }
 568
 569 /*
 570  * stop read and write channel
 571  */
 572 static int
 573 lcs_stop_channels(struct lcs_card *card)
 574 {
 575         LCS_DBF_TEXT(2, trace, "chhalt");
 576         lcs_stop_channel(&card->read);
 577         lcs_stop_channel(&card->write);
 578         return 0;
 579 }
 580
 581 /*
 582  * Get empty buffer.
 583  */
 584 static struct lcs_buffer *
 585 __lcs_get_buffer(struct lcs_channel *channel)
 586 {
 587         int index;
 588
 589         LCS_DBF_TEXT(5, trace, "_getbuff");
 590         index = channel->io_idx;
 591         do {
 592                 if (channel->iob[index].state == LCS_BUF_STATE_EMPTY) {
 593                         channel->iob[index].state = LCS_BUF_STATE_LOCKED;
 594                         return channel->iob + index;
 595                 }
 596                 index = (index + 1) & (LCS_NUM_BUFFS - 1);
 597         } while (index != channel->io_idx);
 598         return NULL;
 599 }
 600
 601 static struct lcs_buffer *
 602 lcs_get_buffer(struct lcs_channel *channel)
 603 {
 604         struct lcs_buffer *buffer;
 605         unsigned long flags;
 606
 607         LCS_DBF_TEXT(5, trace, "getbuff");
 608         spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
 609         buffer = __lcs_get_buffer(channel);
 610         spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
 611         return buffer;
 612 }
 613
 614 /*
 615  * Resume channel program if the channel is suspended.
 616  */
 617 static int
 618 __lcs_resume_channel(struct lcs_channel *channel)
 619 {
 620         int rc;
 621
 622         if (channel->state != LCS_CH_STATE_SUSPENDED)
 623                 return 0;
 624         if (channel->ccws[channel->io_idx].flags & CCW_FLAG_SUSPEND)
 625                 return 0;
 626         LCS_DBF_TEXT_(5, trace, "rsch%s", dev_name(&channel->ccwdev->dev));
 627         rc = ccw_device_resume(channel->ccwdev);
 628         if (rc) {
 629                 LCS_DBF_TEXT_(4, trace, "ersc%s",
 630                               dev_name(&channel->ccwdev->dev));
 631                 dev_err(&channel->ccwdev->dev,
 632                         "Sending data from the LCS device to the LAN failed"
 633                         " with rc=%d\n",rc);
 634         } else
 635                 channel->state = LCS_CH_STATE_RUNNING;
 636         return rc;
 637
 638 }
 639
 640 /*
 641  * Make a buffer ready for processing.
 642  */
 643 static void __lcs_ready_buffer_bits(struct lcs_channel *channel, int index)
 644 {
 645         int prev, next;
 646
 647         LCS_DBF_TEXT(5, trace, "rdybits");
 648         prev = (index - 1) & (LCS_NUM_BUFFS - 1);
 649         next = (index + 1) & (LCS_NUM_BUFFS - 1);
 650         /* Check if we may clear the suspend bit of this buffer. */
 651         if (channel->ccws[next].flags & CCW_FLAG_SUSPEND) {
 652                 /* Check if we have to set the PCI bit. */
 653                 if (!(channel->ccws[prev].flags & CCW_FLAG_SUSPEND))
 654                         /* Suspend bit of the previous buffer is not set. */
 655                         channel->ccws[index].flags |= CCW_FLAG_PCI;
 656                 /* Suspend bit of the next buffer is set. */
 657                 channel->ccws[index].flags &= ~CCW_FLAG_SUSPEND;
 658         }
 659 }
 660
 661 static int
 662 lcs_ready_buffer(struct lcs_channel *channel, struct lcs_buffer *buffer)
 663 {
 664         unsigned long flags;
 665         int index, rc;
 666
 667         LCS_DBF_TEXT(5, trace, "rdybuff");
 668         BUG_ON(buffer->state != LCS_BUF_STATE_LOCKED &&
 669                buffer->state != LCS_BUF_STATE_PROCESSED);
 670         spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
 671         buffer->state = LCS_BUF_STATE_READY;
 672         index = buffer - channel->iob;
 673         /* Set length. */
 674         channel->ccws[index].count = buffer->count;
 675         /* Check relevant PCI/suspend bits. */
 676         __lcs_ready_buffer_bits(channel, index);
 677         rc = __lcs_resume_channel(channel);
 678         spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
 679         return rc;
 680 }
 681
 682 /*
 683  * Mark the buffer as processed. Take care of the suspend bit
 684  * of the previous buffer. This function is called from
 685  * interrupt context, so the lock must not be taken.
 686  */
 687 static int
 688 __lcs_processed_buffer(struct lcs_channel *channel, struct lcs_buffer *buffer)
 689 {
 690         int index, prev, next;
 691
 692         LCS_DBF_TEXT(5, trace, "prcsbuff");
 693         BUG_ON(buffer->state != LCS_BUF_STATE_READY);
 694         buffer->state = LCS_BUF_STATE_PROCESSED;
 695         index = buffer - channel->iob;
 696         prev = (index - 1) & (LCS_NUM_BUFFS - 1);
 697         next = (index + 1) & (LCS_NUM_BUFFS - 1);
 698         /* Set the suspend bit and clear the PCI bit of this buffer. */
 699         channel->ccws[index].flags |= CCW_FLAG_SUSPEND;
 700         channel->ccws[index].flags &= ~CCW_FLAG_PCI;
 701         /* Check the suspend bit of the previous buffer. */
 702         if (channel->iob[prev].state == LCS_BUF_STATE_READY) {
 703                 /*
 704                  * Previous buffer is in state ready. It might have
 705                  * happened in lcs_ready_buffer that the suspend bit
 706                  * has not been cleared to avoid an endless loop.
 707                  * Do it now.
 708                  */
 709                 __lcs_ready_buffer_bits(channel, prev);
 710         }
 711         /* Clear PCI bit of next buffer. */
 712         channel->ccws[next].flags &= ~CCW_FLAG_PCI;
 713         return __lcs_resume_channel(channel);
 714 }
 715
 716 /*
 717  * Put a processed buffer back to state empty.
 718  */
 719 static void
 720 lcs_release_buffer(struct lcs_channel *channel, struct lcs_buffer *buffer)
 721 {
 722         unsigned long flags;
 723
 724         LCS_DBF_TEXT(5, trace, "relbuff");
 725         BUG_ON(buffer->state != LCS_BUF_STATE_LOCKED &&
 726                buffer->state != LCS_BUF_STATE_PROCESSED);
 727         spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
 728         buffer->state = LCS_BUF_STATE_EMPTY;
 729         spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
 730 }
 731
 732 /*
 733  * Get buffer for a lan command.
 734  */
 735 static struct lcs_buffer *
 736 lcs_get_lancmd(struct lcs_card *card, int count)
 737 {
 738         struct lcs_buffer *buffer;
 739         struct lcs_cmd *cmd;
 740
 741         LCS_DBF_TEXT(4, trace, "getlncmd");
 742         /* Get buffer and wait if none is available. */
 743         wait_event(card->write.wait_q,
 744                    ((buffer = lcs_get_buffer(&card->write)) != NULL));
 745         count += sizeof(struct lcs_header);
 746         *(__u16 *)(buffer->data + count) = 0;
 747         buffer->count = count + sizeof(__u16);
 748         buffer->callback = lcs_release_buffer;
 749         cmd = (struct lcs_cmd *) buffer->data;
 750         cmd->offset = count;
 751         cmd->type = LCS_FRAME_TYPE_CONTROL;
 752         cmd->slot = 0;
 753         return buffer;
 754 }
 755
 756
 757 static void
 758 lcs_get_reply(struct lcs_reply *reply)
 759 {
 760         refcount_inc(&reply->refcnt);
 761 }
 762
 763 static void
 764 lcs_put_reply(struct lcs_reply *reply)
 765 {
 766         if (refcount_dec_and_test(&reply->refcnt))
 767                 kfree(reply);
 768 }
 769
 770 static struct lcs_reply *
 771 lcs_alloc_reply(struct lcs_cmd *cmd)
 772 {
 773         struct lcs_reply *reply;
 774
 775         LCS_DBF_TEXT(4, trace, "getreply");
 776
 777         reply = kzalloc(sizeof(struct lcs_reply), GFP_ATOMIC);
 778         if (!reply)
 779                 return NULL;
 780         refcount_set(&reply->refcnt, 1);
 781         reply->sequence_no = cmd->sequence_no;
 782         reply->received = 0;
 783         reply->rc = 0;
 784         init_waitqueue_head(&reply->wait_q);
 785
 786         return reply;
 787 }
 788
 789 /*
 790  * Notifier function for lancmd replies. Called from read irq.
 791  */
 792 static void
 793 lcs_notify_lancmd_waiters(struct lcs_card *card, struct lcs_cmd *cmd)
 794 {
 795         struct list_head *l, *n;
 796         struct lcs_reply *reply;
 797
 798         LCS_DBF_TEXT(4, trace, "notiwait");
 799         spin_lock(&card->lock);
 800         list_for_each_safe(l, n, &card->lancmd_waiters) {
 801                 reply = list_entry(l, struct lcs_reply, list);
 802                 if (reply->sequence_no == cmd->sequence_no) {
 803                         lcs_get_reply(reply);
 804                         list_del_init(&reply->list);
 805                         if (reply->callback != NULL)
 806                                 reply->callback(card, cmd);
 807                         reply->received = 1;
 808                         reply->rc = cmd->return_code;
 809                         wake_up(&reply->wait_q);
 810                         lcs_put_reply(reply);
 811                         break;
 812                 }
 813         }
 814         spin_unlock(&card->lock);
 815 }
 816
 817 /*
 818  * Emit buffer of a lan command.
 819  */
 820 static void
 821 lcs_lancmd_timeout(struct timer_list *t)
 822 {
 823         struct lcs_reply *reply = from_timer(reply, t, timer);
 824         struct lcs_reply *list_reply, *r;
 825         unsigned long flags;
 826
 827         LCS_DBF_TEXT(4, trace, "timeout");
 828         spin_lock_irqsave(&reply->card->lock, flags);
 829         list_for_each_entry_safe(list_reply, r,
 830                                  &reply->card->lancmd_waiters,list) {
 831                 if (reply == list_reply) {
 832                         lcs_get_reply(reply);
 833                         list_del_init(&reply->list);
 834                         spin_unlock_irqrestore(&reply->card->lock, flags);
 835                         reply->received = 1;
 836                         reply->rc = -ETIME;
 837                         wake_up(&reply->wait_q);
 838                         lcs_put_reply(reply);
 839                         return;
 840                 }
 841         }
 842         spin_unlock_irqrestore(&reply->card->lock, flags);
 843 }
 844
 845 static int
 846 lcs_send_lancmd(struct lcs_card *card, struct lcs_buffer *buffer,
 847                 void (*reply_callback)(struct lcs_card *, struct lcs_cmd *))
 848 {
 849         struct lcs_reply *reply;
 850         struct lcs_cmd *cmd;
 851         unsigned long flags;
 852         int rc;
 853
 854         LCS_DBF_TEXT(4, trace, "sendcmd");
 855         cmd = (struct lcs_cmd *) buffer->data;
 856         cmd->return_code = 0;
 857         cmd->sequence_no = card->sequence_no++;
 858         reply = lcs_alloc_reply(cmd);
 859         if (!reply)
 860                 return -ENOMEM;
 861         reply->callback = reply_callback;
 862         reply->card = card;
 863         spin_lock_irqsave(&card->lock, flags);
 864         list_add_tail(&reply->list, &card->lancmd_waiters);
 865         spin_unlock_irqrestore(&card->lock, flags);
 866
 867         buffer->callback = lcs_release_buffer;
 868         rc = lcs_ready_buffer(&card->write, buffer);
 869         if (rc)
 870                 return rc;
 871         timer_setup(&reply->timer, lcs_lancmd_timeout, 0);
 872         mod_timer(&reply->timer, jiffies + HZ * card->lancmd_timeout);
 873         wait_event(reply->wait_q, reply->received);
 874         del_timer_sync(&reply->timer);
 875         LCS_DBF_TEXT_(4, trace, "rc:%d",reply->rc);
 876         rc = reply->rc;
 877         lcs_put_reply(reply);
 878         return rc ? -EIO : 0;
 879 }
 880
 881 /*
 882  * LCS startup command
 883  */
 884 static int
 885 lcs_send_startup(struct lcs_card *card, __u8 initiator)
 886 {
 887         struct lcs_buffer *buffer;
 888         struct lcs_cmd *cmd;
 889
 890         LCS_DBF_TEXT(2, trace, "startup");
 891         buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
 892         cmd = (struct lcs_cmd *) buffer->data;
 893         cmd->cmd_code = LCS_CMD_STARTUP;
 894         cmd->initiator = initiator;
 895         cmd->cmd.lcs_startup.buff_size = LCS_IOBUFFERSIZE;
 896         return lcs_send_lancmd(card, buffer, NULL);
 897 }
 898
 899 /*
 900  * LCS shutdown command
 901  */
 902 static int
 903 lcs_send_shutdown(struct lcs_card *card)
 904 {
 905         struct lcs_buffer *buffer;
 906         struct lcs_cmd *cmd;
 907
 908         LCS_DBF_TEXT(2, trace, "shutdown");
 909         buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
 910         cmd = (struct lcs_cmd *) buffer->data;
 911         cmd->cmd_code = LCS_CMD_SHUTDOWN;
 912         cmd->initiator = LCS_INITIATOR_TCPIP;
 913         return lcs_send_lancmd(card, buffer, NULL);
 914 }
 915
 916 /*
 917  * LCS lanstat command
 918  */
 919 static void
 920 __lcs_lanstat_cb(struct lcs_card *card, struct lcs_cmd *cmd)
 921 {
 922         LCS_DBF_TEXT(2, trace, "statcb");
 923         memcpy(card->mac, cmd->cmd.lcs_lanstat_cmd.mac_addr, LCS_MAC_LENGTH);
 924 }
 925
 926 static int
 927 lcs_send_lanstat(struct lcs_card *card)
 928 {
 929         struct lcs_buffer *buffer;
 930         struct lcs_cmd *cmd;
 931
 932         LCS_DBF_TEXT(2,trace, "cmdstat");
 933         buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
 934         cmd = (struct lcs_cmd *) buffer->data;
 935         /* Setup lanstat command. */
 936         cmd->cmd_code = LCS_CMD_LANSTAT;
 937         cmd->initiator = LCS_INITIATOR_TCPIP;
 938         cmd->cmd.lcs_std_cmd.lan_type = card->lan_type;
 939         cmd->cmd.lcs_std_cmd.portno = card->portno;
 940         return lcs_send_lancmd(card, buffer, __lcs_lanstat_cb);
 941 }
 942
 943 /*
 944  * send stoplan command
 945  */
 946 static int
 947 lcs_send_stoplan(struct lcs_card *card, __u8 initiator)
 948 {
 949         struct lcs_buffer *buffer;
 950         struct lcs_cmd *cmd;
 951
 952         LCS_DBF_TEXT(2, trace, "cmdstpln");
 953         buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
 954         cmd = (struct lcs_cmd *) buffer->data;
 955         cmd->cmd_code = LCS_CMD_STOPLAN;
 956         cmd->initiator = initiator;
 957         cmd->cmd.lcs_std_cmd.lan_type = card->lan_type;
 958         cmd->cmd.lcs_std_cmd.portno = card->portno;
 959         return lcs_send_lancmd(card, buffer, NULL);
 960 }
 961
 962 /*
 963  * send startlan command
 964  */
 965 static void
 966 __lcs_send_startlan_cb(struct lcs_card *card, struct lcs_cmd *cmd)
 967 {
 968         LCS_DBF_TEXT(2, trace, "srtlancb");
 969         card->lan_type = cmd->cmd.lcs_std_cmd.lan_type;
 970         card->portno = cmd->cmd.lcs_std_cmd.portno;
 971 }
 972
 973 static int
 974 lcs_send_startlan(struct lcs_card *card, __u8 initiator)
 975 {
 976         struct lcs_buffer *buffer;
 977         struct lcs_cmd *cmd;
 978
 979         LCS_DBF_TEXT(2, trace, "cmdstaln");
 980         buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
 981         cmd = (struct lcs_cmd *) buffer->data;
 982         cmd->cmd_code = LCS_CMD_STARTLAN;
 983         cmd->initiator = initiator;
 984         cmd->cmd.lcs_std_cmd.lan_type = card->lan_type;
 985         cmd->cmd.lcs_std_cmd.portno = card->portno;
 986         return lcs_send_lancmd(card, buffer, __lcs_send_startlan_cb);
 987 }
 988
 989 #ifdef CONFIG_IP_MULTICAST
 990 /*
 991  * send setipm command (Multicast)
 992  */
 993 static int
 994 lcs_send_setipm(struct lcs_card *card,struct lcs_ipm_list *ipm_list)
 995 {
 996         struct lcs_buffer *buffer;
 997         struct lcs_cmd *cmd;
 998
 999         LCS_DBF_TEXT(2, trace, "cmdsetim");
1000         buffer = lcs_get_lancmd(card, LCS_MULTICAST_CMD_SIZE);
1001         cmd = (struct lcs_cmd *) buffer->data;
1002         cmd->cmd_code = LCS_CMD_SETIPM;
1003         cmd->initiator = LCS_INITIATOR_TCPIP;
1004         cmd->cmd.lcs_qipassist.lan_type = card->lan_type;
1005         cmd->cmd.lcs_qipassist.portno = card->portno;
1006         cmd->cmd.lcs_qipassist.version = 4;
1007         cmd->cmd.lcs_qipassist.num_ip_pairs = 1;
1008         memcpy(cmd->cmd.lcs_qipassist.lcs_ipass_ctlmsg.ip_mac_pair,
1009                &ipm_list->ipm, sizeof (struct lcs_ip_mac_pair));
1010         LCS_DBF_TEXT_(2, trace, "%x",ipm_list->ipm.ip_addr);
1011         return lcs_send_lancmd(card, buffer, NULL);
1012 }
1013
1014 /*
1015  * 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                         pr_warn("Stoplan for %s initiated by LGW\n",
1740                                 card->dev->name);
1741                         if (card->dev)
1742                                 netif_carrier_off(card->dev);
1743                         break;
1744                 default:
1745                         LCS_DBF_TEXT(5, trace, "noLGWcmd");
1746                         break;
1747                 }
1748         } else
1749                 lcs_notify_lancmd_waiters(card, cmd);
1750 }
1751
1752 /*
1753  * Unpack network packet.
1754  */
1755 static void
1756 lcs_get_skb(struct lcs_card *card, char *skb_data, unsigned int skb_len)
1757 {
1758         struct sk_buff *skb;
1759
1760         LCS_DBF_TEXT(5, trace, "getskb");
1761         if (card->dev == NULL ||
1762             card->state != DEV_STATE_UP)
1763                 /* The card isn't up. Ignore the packet. */
1764                 return;
1765
1766         skb = dev_alloc_skb(skb_len);
1767         if (skb == NULL) {
1768                 dev_err(&card->dev->dev,
1769                         " Allocating a socket buffer to interface %s failed\n",
1770                           card->dev->name);
1771                 card->stats.rx_dropped++;
1772                 return;
1773         }
1774         skb_put_data(skb, skb_data, skb_len);
1775         skb->protocol = card->lan_type_trans(skb, card->dev);
1776         card->stats.rx_bytes += skb_len;
1777         card->stats.rx_packets++;
1778         if (skb->protocol == htons(ETH_P_802_2))
1779                 *((__u32 *)skb->cb) = ++card->pkt_seq;
1780         netif_rx(skb);
1781 }
1782
1783 /*
1784  * LCS main routine to get packets and lancmd replies from the buffers
1785  */
1786 static void
1787 lcs_get_frames_cb(struct lcs_channel *channel, struct lcs_buffer *buffer)
1788 {
1789         struct lcs_card *card;
1790         struct lcs_header *lcs_hdr;
1791         __u16 offset;
1792
1793         LCS_DBF_TEXT(5, trace, "lcsgtpkt");
1794         lcs_hdr = (struct lcs_header *) buffer->data;
1795         if (lcs_hdr->offset == LCS_ILLEGAL_OFFSET) {
1796                 LCS_DBF_TEXT(4, trace, "-eiogpkt");
1797                 return;
1798         }
1799         card = container_of(channel, struct lcs_card, read);
1800         offset = 0;
1801         while (lcs_hdr->offset != 0) {
1802                 if (lcs_hdr->offset <= 0 ||
1803                     lcs_hdr->offset > LCS_IOBUFFERSIZE ||
1804                     lcs_hdr->offset < offset) {
1805                         /* Offset invalid. */
1806                         card->stats.rx_length_errors++;
1807                         card->stats.rx_errors++;
1808                         return;
1809                 }
1810                 /* What kind of frame is it? */
1811                 if (lcs_hdr->type == LCS_FRAME_TYPE_CONTROL) {
1812                         /* Control frame. */
1813                         lcs_get_control(card, (struct lcs_cmd *) lcs_hdr);
1814                 } else if (lcs_hdr->type == LCS_FRAME_TYPE_ENET ||
1815                            lcs_hdr->type == LCS_FRAME_TYPE_TR ||
1816                            lcs_hdr->type == LCS_FRAME_TYPE_FDDI) {
1817                         /* Normal network packet. */
1818                         lcs_get_skb(card, (char *)(lcs_hdr + 1),
1819                                     lcs_hdr->offset - offset -
1820                                     sizeof(struct lcs_header));
1821                 } else {
1822                         /* Unknown frame type. */
1823                         ; // FIXME: error message ?
1824                 }
1825                 /* Proceed to next frame. */
1826                 offset = lcs_hdr->offset;
1827                 lcs_hdr->offset = LCS_ILLEGAL_OFFSET;
1828                 lcs_hdr = (struct lcs_header *) (buffer->data + offset);
1829         }
1830         /* The buffer is now empty. Make it ready again. */
1831         lcs_ready_buffer(&card->read, buffer);
1832 }
1833
1834 /*
1835  * get network statistics for ifconfig and other user programs
1836  */
1837 static struct net_device_stats *
1838 lcs_getstats(struct net_device *dev)
1839 {
1840         struct lcs_card *card;
1841
1842         LCS_DBF_TEXT(4, trace, "netstats");
1843         card = (struct lcs_card *) dev->ml_priv;
1844         return &card->stats;
1845 }
1846
1847 /*
1848  * stop lcs device
1849  * This function will be called by user doing ifconfig xxx down
1850  */
1851 static int
1852 lcs_stop_device(struct net_device *dev)
1853 {
1854         struct lcs_card *card;
1855         int rc;
1856
1857         LCS_DBF_TEXT(2, trace, "stopdev");
1858         card   = (struct lcs_card *) dev->ml_priv;
1859         netif_carrier_off(dev);
1860         netif_tx_disable(dev);
1861         dev->flags &= ~IFF_UP;
1862         wait_event(card->write.wait_q,
1863                 (card->write.state != LCS_CH_STATE_RUNNING));
1864         rc = lcs_stopcard(card);
1865         if (rc)
1866                 dev_err(&card->dev->dev,
1867                         " Shutting down the LCS device failed\n");
1868         return rc;
1869 }
1870
1871 /*
1872  * start lcs device and make it runnable
1873  * This function will be called by user doing ifconfig xxx up
1874  */
1875 static int
1876 lcs_open_device(struct net_device *dev)
1877 {
1878         struct lcs_card *card;
1879         int rc;
1880
1881         LCS_DBF_TEXT(2, trace, "opendev");
1882         card = (struct lcs_card *) dev->ml_priv;
1883         /* initialize statistics */
1884         rc = lcs_detect(card);
1885         if (rc) {
1886                 pr_err("Error in opening device!\n");
1887
1888         } else {
1889                 dev->flags |= IFF_UP;
1890                 netif_carrier_on(dev);
1891                 netif_wake_queue(dev);
1892                 card->state = DEV_STATE_UP;
1893         }
1894         return rc;
1895 }
1896
1897 /*
1898  * show function for portno called by cat or similar things
1899  */
1900 static ssize_t
1901 lcs_portno_show (struct device *dev, struct device_attribute *attr, char *buf)
1902 {
1903         struct lcs_card *card;
1904
1905         card = dev_get_drvdata(dev);
1906
1907         if (!card)
1908                 return 0;
1909
1910         return sprintf(buf, "%d\n", card->portno);
1911 }
1912
1913 /*
1914  * store the value which is piped to file portno
1915  */
1916 static ssize_t
1917 lcs_portno_store (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1918 {
1919         struct lcs_card *card;
1920         int rc;
1921         s16 value;
1922
1923         card = dev_get_drvdata(dev);
1924
1925         if (!card)
1926                 return 0;
1927
1928         rc = kstrtos16(buf, 0, &value);
1929         if (rc)
1930                 return -EINVAL;
1931         /* TODO: sanity checks */
1932         card->portno = value;
1933         if (card->dev)
1934                 card->dev->dev_port = card->portno;
1935
1936         return count;
1937
1938 }
1939
1940 static DEVICE_ATTR(portno, 0644, lcs_portno_show, lcs_portno_store);
1941
1942 static const char *lcs_type[] = {
1943         "not a channel",
1944         "2216 parallel",
1945         "2216 channel",
1946         "OSA LCS card",
1947         "unknown channel type",
1948         "unsupported channel type",
1949 };
1950
1951 static ssize_t
1952 lcs_type_show(struct device *dev, struct device_attribute *attr, char *buf)
1953 {
1954         struct ccwgroup_device *cgdev;
1955
1956         cgdev = to_ccwgroupdev(dev);
1957         if (!cgdev)
1958                 return -ENODEV;
1959
1960         return sprintf(buf, "%s\n", lcs_type[cgdev->cdev[0]->id.driver_info]);
1961 }
1962
1963 static DEVICE_ATTR(type, 0444, lcs_type_show, NULL);
1964
1965 static ssize_t
1966 lcs_timeout_show(struct device *dev, struct device_attribute *attr, char *buf)
1967 {
1968         struct lcs_card *card;
1969
1970         card = dev_get_drvdata(dev);
1971
1972         return card ? sprintf(buf, "%u\n", card->lancmd_timeout) : 0;
1973 }
1974
1975 static ssize_t
1976 lcs_timeout_store (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1977 {
1978         struct lcs_card *card;
1979         unsigned int value;
1980         int rc;
1981
1982         card = dev_get_drvdata(dev);
1983
1984         if (!card)
1985                 return 0;
1986
1987         rc = kstrtouint(buf, 0, &value);
1988         if (rc)
1989                 return -EINVAL;
1990         /* TODO: sanity checks */
1991         card->lancmd_timeout = value;
1992
1993         return count;
1994
1995 }
1996
1997 static DEVICE_ATTR(lancmd_timeout, 0644, lcs_timeout_show, lcs_timeout_store);
1998
1999 static ssize_t
2000 lcs_dev_recover_store(struct device *dev, struct device_attribute *attr,
2001                       const char *buf, size_t count)
2002 {
2003         struct lcs_card *card = dev_get_drvdata(dev);
2004         char *tmp;
2005         int i;
2006
2007         if (!card)
2008                 return -EINVAL;
2009         if (card->state != DEV_STATE_UP)
2010                 return -EPERM;
2011         i = simple_strtoul(buf, &tmp, 16);
2012         if (i == 1)
2013                 lcs_schedule_recovery(card);
2014         return count;
2015 }
2016
2017 static DEVICE_ATTR(recover, 0200, NULL, lcs_dev_recover_store);
2018
2019 static struct attribute * lcs_attrs[] = {
2020         &dev_attr_portno.attr,
2021         &dev_attr_type.attr,
2022         &dev_attr_lancmd_timeout.attr,
2023         &dev_attr_recover.attr,
2024         NULL,
2025 };
2026 static struct attribute_group lcs_attr_group = {
2027         .attrs = lcs_attrs,
2028 };
2029 static const struct attribute_group *lcs_attr_groups[] = {
2030         &lcs_attr_group,
2031         NULL,
2032 };
2033 static const struct device_type lcs_devtype = {
2034         .name = "lcs",
2035         .groups = lcs_attr_groups,
2036 };
2037
2038 /*
2039  * lcs_probe_device is called on establishing a new ccwgroup_device.
2040  */
2041 static int
2042 lcs_probe_device(struct ccwgroup_device *ccwgdev)
2043 {
2044         struct lcs_card *card;
2045
2046         if (!get_device(&ccwgdev->dev))
2047                 return -ENODEV;
2048
2049         LCS_DBF_TEXT(2, setup, "add_dev");
2050         card = lcs_alloc_card();
2051         if (!card) {
2052                 LCS_DBF_TEXT_(2, setup, "  rc%d", -ENOMEM);
2053                 put_device(&ccwgdev->dev);
2054                 return -ENOMEM;
2055         }
2056         dev_set_drvdata(&ccwgdev->dev, card);
2057         ccwgdev->cdev[0]->handler = lcs_irq;
2058         ccwgdev->cdev[1]->handler = lcs_irq;
2059         card->gdev = ccwgdev;
2060         INIT_WORK(&card->kernel_thread_starter, lcs_start_kernel_thread);
2061         card->thread_start_mask = 0;
2062         card->thread_allowed_mask = 0;
2063         card->thread_running_mask = 0;
2064         ccwgdev->dev.type = &lcs_devtype;
2065
2066         return 0;
2067 }
2068
2069 static int
2070 lcs_register_netdev(struct ccwgroup_device *ccwgdev)
2071 {
2072         struct lcs_card *card;
2073
2074         LCS_DBF_TEXT(2, setup, "regnetdv");
2075         card = dev_get_drvdata(&ccwgdev->dev);
2076         if (card->dev->reg_state != NETREG_UNINITIALIZED)
2077                 return 0;
2078         SET_NETDEV_DEV(card->dev, &ccwgdev->dev);
2079         return register_netdev(card->dev);
2080 }
2081
2082 /*
2083  * lcs_new_device will be called by setting the group device online.
2084  */
2085 static const struct net_device_ops lcs_netdev_ops = {
2086         .ndo_open               = lcs_open_device,
2087         .ndo_stop               = lcs_stop_device,
2088         .ndo_get_stats          = lcs_getstats,
2089         .ndo_start_xmit         = lcs_start_xmit,
2090 };
2091
2092 static const struct net_device_ops lcs_mc_netdev_ops = {
2093         .ndo_open               = lcs_open_device,
2094         .ndo_stop               = lcs_stop_device,
2095         .ndo_get_stats          = lcs_getstats,
2096         .ndo_start_xmit         = lcs_start_xmit,
2097         .ndo_set_rx_mode        = lcs_set_multicast_list,
2098 };
2099
2100 static int
2101 lcs_new_device(struct ccwgroup_device *ccwgdev)
2102 {
2103         struct  lcs_card *card;
2104         struct net_device *dev=NULL;
2105         enum lcs_dev_states recover_state;
2106         int rc;
2107
2108         card = dev_get_drvdata(&ccwgdev->dev);
2109         if (!card)
2110                 return -ENODEV;
2111
2112         LCS_DBF_TEXT(2, setup, "newdev");
2113         LCS_DBF_HEX(3, setup, &card, sizeof(void*));
2114         card->read.ccwdev  = ccwgdev->cdev[0];
2115         card->write.ccwdev = ccwgdev->cdev[1];
2116
2117         recover_state = card->state;
2118         rc = ccw_device_set_online(card->read.ccwdev);
2119         if (rc)
2120                 goto out_err;
2121         rc = ccw_device_set_online(card->write.ccwdev);
2122         if (rc)
2123                 goto out_werr;
2124
2125         LCS_DBF_TEXT(3, setup, "lcsnewdv");
2126
2127         lcs_setup_card(card);
2128         rc = lcs_detect(card);
2129         if (rc) {
2130                 LCS_DBF_TEXT(2, setup, "dtctfail");
2131                 dev_err(&ccwgdev->dev,
2132                         "Detecting a network adapter for LCS devices"
2133                         " failed with rc=%d (0x%x)\n", rc, rc);
2134                 lcs_stopcard(card);
2135                 goto out;
2136         }
2137         if (card->dev) {
2138                 LCS_DBF_TEXT(2, setup, "samedev");
2139                 LCS_DBF_HEX(3, setup, &card, sizeof(void*));
2140                 goto netdev_out;
2141         }
2142         switch (card->lan_type) {
2143 #ifdef CONFIG_ETHERNET
2144         case LCS_FRAME_TYPE_ENET:
2145                 card->lan_type_trans = eth_type_trans;
2146                 dev = alloc_etherdev(0);
2147                 break;
2148 #endif
2149 #ifdef CONFIG_FDDI
2150         case LCS_FRAME_TYPE_FDDI:
2151                 card->lan_type_trans = fddi_type_trans;
2152                 dev = alloc_fddidev(0);
2153                 break;
2154 #endif
2155         default:
2156                 LCS_DBF_TEXT(3, setup, "errinit");
2157                 pr_err(" Initialization failed\n");
2158                 goto out;
2159         }
2160         if (!dev)
2161                 goto out;
2162         card->dev = dev;
2163         card->dev->ml_priv = card;
2164         card->dev->netdev_ops = &lcs_netdev_ops;
2165         card->dev->dev_port = card->portno;
2166         eth_hw_addr_set(card->dev, card->mac);
2167 #ifdef CONFIG_IP_MULTICAST
2168         if (!lcs_check_multicast_support(card))
2169                 card->dev->netdev_ops = &lcs_mc_netdev_ops;
2170 #endif
2171 netdev_out:
2172         lcs_set_allowed_threads(card,0xffffffff);
2173         if (recover_state == DEV_STATE_RECOVER) {
2174                 lcs_set_multicast_list(card->dev);
2175                 card->dev->flags |= IFF_UP;
2176                 netif_carrier_on(card->dev);
2177                 netif_wake_queue(card->dev);
2178                 card->state = DEV_STATE_UP;
2179         } else {
2180                 lcs_stopcard(card);
2181         }
2182
2183         if (lcs_register_netdev(ccwgdev) != 0)
2184                 goto out;
2185
2186         /* Print out supported assists: IPv6 */
2187         pr_info("LCS device %s %s IPv6 support\n", card->dev->name,
2188                 (card->ip_assists_supported & LCS_IPASS_IPV6_SUPPORT) ?
2189                 "with" : "without");
2190         /* Print out supported assist: Multicast */
2191         pr_info("LCS device %s %s Multicast support\n", card->dev->name,
2192                 (card->ip_assists_supported & LCS_IPASS_MULTICAST_SUPPORT) ?
2193                 "with" : "without");
2194         return 0;
2195 out:
2196
2197         ccw_device_set_offline(card->write.ccwdev);
2198 out_werr:
2199         ccw_device_set_offline(card->read.ccwdev);
2200 out_err:
2201         return -ENODEV;
2202 }
2203
2204 /*
2205  * lcs_shutdown_device, called when setting the group device offline.
2206  */
2207 static int
2208 __lcs_shutdown_device(struct ccwgroup_device *ccwgdev, int recovery_mode)
2209 {
2210         struct lcs_card *card;
2211         enum lcs_dev_states recover_state;
2212         int ret = 0, ret2 = 0, ret3 = 0;
2213
2214         LCS_DBF_TEXT(3, setup, "shtdndev");
2215         card = dev_get_drvdata(&ccwgdev->dev);
2216         if (!card)
2217                 return -ENODEV;
2218         if (recovery_mode == 0) {
2219                 lcs_set_allowed_threads(card, 0);
2220                 if (lcs_wait_for_threads(card, LCS_SET_MC_THREAD))
2221                         return -ERESTARTSYS;
2222         }
2223         LCS_DBF_HEX(3, setup, &card, sizeof(void*));
2224         recover_state = card->state;
2225
2226         ret = lcs_stop_device(card->dev);
2227         ret2 = ccw_device_set_offline(card->read.ccwdev);
2228         ret3 = ccw_device_set_offline(card->write.ccwdev);
2229         if (!ret)
2230                 ret = (ret2) ? ret2 : ret3;
2231         if (ret)
2232                 LCS_DBF_TEXT_(3, setup, "1err:%d", ret);
2233         if (recover_state == DEV_STATE_UP) {
2234                 card->state = DEV_STATE_RECOVER;
2235         }
2236         return 0;
2237 }
2238
2239 static int
2240 lcs_shutdown_device(struct ccwgroup_device *ccwgdev)
2241 {
2242         return __lcs_shutdown_device(ccwgdev, 0);
2243 }
2244
2245 /*
2246  * drive lcs recovery after startup and startlan initiated by Lan Gateway
2247  */
2248 static int
2249 lcs_recovery(void *ptr)
2250 {
2251         struct lcs_card *card;
2252         struct ccwgroup_device *gdev;
2253         int rc;
2254
2255         card = (struct lcs_card *) ptr;
2256
2257         LCS_DBF_TEXT(4, trace, "recover1");
2258         if (!lcs_do_run_thread(card, LCS_RECOVERY_THREAD))
2259                 return 0;
2260         LCS_DBF_TEXT(4, trace, "recover2");
2261         gdev = card->gdev;
2262         dev_warn(&gdev->dev,
2263                 "A recovery process has been started for the LCS device\n");
2264         rc = __lcs_shutdown_device(gdev, 1);
2265         rc = lcs_new_device(gdev);
2266         if (!rc)
2267                 pr_info("Device %s successfully recovered!\n",
2268                         card->dev->name);
2269         else
2270                 pr_info("Device %s could not be recovered!\n",
2271                         card->dev->name);
2272         lcs_clear_thread_running_bit(card, LCS_RECOVERY_THREAD);
2273         return 0;
2274 }
2275
2276 /*
2277  * lcs_remove_device, free buffers and card
2278  */
2279 static void
2280 lcs_remove_device(struct ccwgroup_device *ccwgdev)
2281 {
2282         struct lcs_card *card;
2283
2284         card = dev_get_drvdata(&ccwgdev->dev);
2285         if (!card)
2286                 return;
2287
2288         LCS_DBF_TEXT(3, setup, "remdev");
2289         LCS_DBF_HEX(3, setup, &card, sizeof(void*));
2290         if (ccwgdev->state == CCWGROUP_ONLINE) {
2291                 lcs_shutdown_device(ccwgdev);
2292         }
2293         if (card->dev)
2294                 unregister_netdev(card->dev);
2295         lcs_cleanup_card(card);
2296         lcs_free_card(card);
2297         dev_set_drvdata(&ccwgdev->dev, NULL);
2298         put_device(&ccwgdev->dev);
2299 }
2300
2301 static struct ccw_device_id lcs_ids[] = {
2302         {CCW_DEVICE(0x3088, 0x08), .driver_info = lcs_channel_type_parallel},
2303         {CCW_DEVICE(0x3088, 0x1f), .driver_info = lcs_channel_type_2216},
2304         {CCW_DEVICE(0x3088, 0x60), .driver_info = lcs_channel_type_osa2},
2305         {},
2306 };
2307 MODULE_DEVICE_TABLE(ccw, lcs_ids);
2308
2309 static struct ccw_driver lcs_ccw_driver = {
2310         .driver = {
2311                 .owner  = THIS_MODULE,
2312                 .name   = "lcs",
2313         },
2314         .ids    = lcs_ids,
2315         .probe  = ccwgroup_probe_ccwdev,
2316         .remove = ccwgroup_remove_ccwdev,
2317         .int_class = IRQIO_LCS,
2318 };
2319
2320 /*
2321  * LCS ccwgroup driver registration
2322  */
2323 static struct ccwgroup_driver lcs_group_driver = {
2324         .driver = {
2325                 .owner  = THIS_MODULE,
2326                 .name   = "lcs",
2327         },
2328         .ccw_driver  = &lcs_ccw_driver,
2329         .setup       = lcs_probe_device,
2330         .remove      = lcs_remove_device,
2331         .set_online  = lcs_new_device,
2332         .set_offline = lcs_shutdown_device,
2333 };
2334
2335 static ssize_t group_store(struct device_driver *ddrv, const char *buf,
2336                            size_t count)
2337 {
2338         int err;
2339         err = ccwgroup_create_dev(lcs_root_dev, &lcs_group_driver, 2, buf);
2340         return err ? err : count;
2341 }
2342 static DRIVER_ATTR_WO(group);
2343
2344 static struct attribute *lcs_drv_attrs[] = {
2345         &driver_attr_group.attr,
2346         NULL,
2347 };
2348 static struct attribute_group lcs_drv_attr_group = {
2349         .attrs = lcs_drv_attrs,
2350 };
2351 static const struct attribute_group *lcs_drv_attr_groups[] = {
2352         &lcs_drv_attr_group,
2353         NULL,
2354 };
2355
2356 /*
2357  *  LCS Module/Kernel initialization function
2358  */
2359 static int
2360 __init lcs_init_module(void)
2361 {
2362         int rc;
2363
2364         pr_info("Loading %s\n", version);
2365         rc = lcs_register_debug_facility();
2366         LCS_DBF_TEXT(0, setup, "lcsinit");
2367         if (rc)
2368                 goto out_err;
2369         lcs_root_dev = root_device_register("lcs");
2370         rc = PTR_ERR_OR_ZERO(lcs_root_dev);
2371         if (rc)
2372                 goto register_err;
2373         rc = ccw_driver_register(&lcs_ccw_driver);
2374         if (rc)
2375                 goto ccw_err;
2376         lcs_group_driver.driver.groups = lcs_drv_attr_groups;
2377         rc = ccwgroup_driver_register(&lcs_group_driver);
2378         if (rc)
2379                 goto ccwgroup_err;
2380         return 0;
2381
2382 ccwgroup_err:
2383         ccw_driver_unregister(&lcs_ccw_driver);
2384 ccw_err:
2385         root_device_unregister(lcs_root_dev);
2386 register_err:
2387         lcs_unregister_debug_facility();
2388 out_err:
2389         pr_err("Initializing the lcs device driver failed\n");
2390         return rc;
2391 }
2392
2393
2394 /*
2395  *  LCS module cleanup function
2396  */
2397 static void
2398 __exit lcs_cleanup_module(void)
2399 {
2400         pr_info("Terminating lcs module.\n");
2401         LCS_DBF_TEXT(0, trace, "cleanup");
2402         ccwgroup_driver_unregister(&lcs_group_driver);
2403         ccw_driver_unregister(&lcs_ccw_driver);
2404         root_device_unregister(lcs_root_dev);
2405         lcs_unregister_debug_facility();
2406 }
2407
2408 module_init(lcs_init_module);
2409 module_exit(lcs_cleanup_module);
2410
2411 MODULE_AUTHOR("Frank Pavlic <fpavlic@de.ibm.com>");
2412 MODULE_LICENSE("GPL");
2413