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) __pa(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) __pa(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) __pa(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) __pa(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  * Cleanup channels,card and state machines.
 456  */
 457 static void
 458 lcs_cleanup_card(struct lcs_card *card)
 459 {
 460
 461         LCS_DBF_TEXT(3, setup, "cleancrd");
 462         LCS_DBF_HEX(2,setup,&card,sizeof(void*));
 463
 464         if (card->dev != NULL)
 465                 free_netdev(card->dev);
 466         /* Cleanup channels. */
 467         lcs_cleanup_channel(&card->write);
 468         lcs_cleanup_channel(&card->read);
 469 }
 470
 471 /**
 472  * Start channel.
 473  */
 474 static int
 475 lcs_start_channel(struct lcs_channel *channel)
 476 {
 477         unsigned long flags;
 478         int rc;
 479
 480         LCS_DBF_TEXT_(4, trace,"ssch%s", dev_name(&channel->ccwdev->dev));
 481         spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
 482         rc = ccw_device_start(channel->ccwdev,
 483                               channel->ccws + channel->io_idx, 0, 0,
 484                               DOIO_DENY_PREFETCH | DOIO_ALLOW_SUSPEND);
 485         if (rc == 0)
 486                 channel->state = LCS_CH_STATE_RUNNING;
 487         spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
 488         if (rc) {
 489                 LCS_DBF_TEXT_(4,trace,"essh%s",
 490                               dev_name(&channel->ccwdev->dev));
 491                 dev_err(&channel->ccwdev->dev,
 492                         "Starting an LCS device resulted in an error,"
 493                         " rc=%d!\n", rc);
 494         }
 495         return rc;
 496 }
 497
 498 static int
 499 lcs_clear_channel(struct lcs_channel *channel)
 500 {
 501         unsigned long flags;
 502         int rc;
 503
 504         LCS_DBF_TEXT(4,trace,"clearch");
 505         LCS_DBF_TEXT_(4, trace, "%s", dev_name(&channel->ccwdev->dev));
 506         spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
 507         rc = ccw_device_clear(channel->ccwdev, (addr_t) channel);
 508         spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
 509         if (rc) {
 510                 LCS_DBF_TEXT_(4, trace, "ecsc%s",
 511                               dev_name(&channel->ccwdev->dev));
 512                 return rc;
 513         }
 514         wait_event(channel->wait_q, (channel->state == LCS_CH_STATE_CLEARED));
 515         channel->state = LCS_CH_STATE_STOPPED;
 516         return rc;
 517 }
 518
 519
 520 /**
 521  * Stop channel.
 522  */
 523 static int
 524 lcs_stop_channel(struct lcs_channel *channel)
 525 {
 526         unsigned long flags;
 527         int rc;
 528
 529         if (channel->state == LCS_CH_STATE_STOPPED)
 530                 return 0;
 531         LCS_DBF_TEXT(4,trace,"haltsch");
 532         LCS_DBF_TEXT_(4, trace, "%s", dev_name(&channel->ccwdev->dev));
 533         channel->state = LCS_CH_STATE_INIT;
 534         spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
 535         rc = ccw_device_halt(channel->ccwdev, (addr_t) channel);
 536         spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
 537         if (rc) {
 538                 LCS_DBF_TEXT_(4, trace, "ehsc%s",
 539                               dev_name(&channel->ccwdev->dev));
 540                 return rc;
 541         }
 542         /* Asynchronous halt initialted. Wait for its completion. */
 543         wait_event(channel->wait_q, (channel->state == LCS_CH_STATE_HALTED));
 544         lcs_clear_channel(channel);
 545         return 0;
 546 }
 547
 548 /**
 549  * start read and write channel
 550  */
 551 static int
 552 lcs_start_channels(struct lcs_card *card)
 553 {
 554         int rc;
 555
 556         LCS_DBF_TEXT(2, trace, "chstart");
 557         /* start read channel */
 558         rc = lcs_start_channel(&card->read);
 559         if (rc)
 560                 return rc;
 561         /* start write channel */
 562         rc = lcs_start_channel(&card->write);
 563         if (rc)
 564                 lcs_stop_channel(&card->read);
 565         return rc;
 566 }
 567
 568 /**
 569  * stop read and write channel
 570  */
 571 static int
 572 lcs_stop_channels(struct lcs_card *card)
 573 {
 574         LCS_DBF_TEXT(2, trace, "chhalt");
 575         lcs_stop_channel(&card->read);
 576         lcs_stop_channel(&card->write);
 577         return 0;
 578 }
 579
 580 /**
 581  * Get empty buffer.
 582  */
 583 static struct lcs_buffer *
 584 __lcs_get_buffer(struct lcs_channel *channel)
 585 {
 586         int index;
 587
 588         LCS_DBF_TEXT(5, trace, "_getbuff");
 589         index = channel->io_idx;
 590         do {
 591                 if (channel->iob[index].state == LCS_BUF_STATE_EMPTY) {
 592                         channel->iob[index].state = LCS_BUF_STATE_LOCKED;
 593                         return channel->iob + index;
 594                 }
 595                 index = (index + 1) & (LCS_NUM_BUFFS - 1);
 596         } while (index != channel->io_idx);
 597         return NULL;
 598 }
 599
 600 static struct lcs_buffer *
 601 lcs_get_buffer(struct lcs_channel *channel)
 602 {
 603         struct lcs_buffer *buffer;
 604         unsigned long flags;
 605
 606         LCS_DBF_TEXT(5, trace, "getbuff");
 607         spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
 608         buffer = __lcs_get_buffer(channel);
 609         spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
 610         return buffer;
 611 }
 612
 613 /**
 614  * Resume channel program if the channel is suspended.
 615  */
 616 static int
 617 __lcs_resume_channel(struct lcs_channel *channel)
 618 {
 619         int rc;
 620
 621         if (channel->state != LCS_CH_STATE_SUSPENDED)
 622                 return 0;
 623         if (channel->ccws[channel->io_idx].flags & CCW_FLAG_SUSPEND)
 624                 return 0;
 625         LCS_DBF_TEXT_(5, trace, "rsch%s", dev_name(&channel->ccwdev->dev));
 626         rc = ccw_device_resume(channel->ccwdev);
 627         if (rc) {
 628                 LCS_DBF_TEXT_(4, trace, "ersc%s",
 629                               dev_name(&channel->ccwdev->dev));
 630                 dev_err(&channel->ccwdev->dev,
 631                         "Sending data from the LCS device to the LAN failed"
 632                         " with rc=%d\n",rc);
 633         } else
 634                 channel->state = LCS_CH_STATE_RUNNING;
 635         return rc;
 636
 637 }
 638
 639 /**
 640  * Make a buffer ready for processing.
 641  */
 642 static void __lcs_ready_buffer_bits(struct lcs_channel *channel, int index)
 643 {
 644         int prev, next;
 645
 646         LCS_DBF_TEXT(5, trace, "rdybits");
 647         prev = (index - 1) & (LCS_NUM_BUFFS - 1);
 648         next = (index + 1) & (LCS_NUM_BUFFS - 1);
 649         /* Check if we may clear the suspend bit of this buffer. */
 650         if (channel->ccws[next].flags & CCW_FLAG_SUSPEND) {
 651                 /* Check if we have to set the PCI bit. */
 652                 if (!(channel->ccws[prev].flags & CCW_FLAG_SUSPEND))
 653                         /* Suspend bit of the previous buffer is not set. */
 654                         channel->ccws[index].flags |= CCW_FLAG_PCI;
 655                 /* Suspend bit of the next buffer is set. */
 656                 channel->ccws[index].flags &= ~CCW_FLAG_SUSPEND;
 657         }
 658 }
 659
 660 static int
 661 lcs_ready_buffer(struct lcs_channel *channel, struct lcs_buffer *buffer)
 662 {
 663         unsigned long flags;
 664         int index, rc;
 665
 666         LCS_DBF_TEXT(5, trace, "rdybuff");
 667         BUG_ON(buffer->state != LCS_BUF_STATE_LOCKED &&
 668                buffer->state != LCS_BUF_STATE_PROCESSED);
 669         spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
 670         buffer->state = LCS_BUF_STATE_READY;
 671         index = buffer - channel->iob;
 672         /* Set length. */
 673         channel->ccws[index].count = buffer->count;
 674         /* Check relevant PCI/suspend bits. */
 675         __lcs_ready_buffer_bits(channel, index);
 676         rc = __lcs_resume_channel(channel);
 677         spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
 678         return rc;
 679 }
 680
 681 /**
 682  * Mark the buffer as processed. Take care of the suspend bit
 683  * of the previous buffer. This function is called from
 684  * interrupt context, so the lock must not be taken.
 685  */
 686 static int
 687 __lcs_processed_buffer(struct lcs_channel *channel, struct lcs_buffer *buffer)
 688 {
 689         int index, prev, next;
 690
 691         LCS_DBF_TEXT(5, trace, "prcsbuff");
 692         BUG_ON(buffer->state != LCS_BUF_STATE_READY);
 693         buffer->state = LCS_BUF_STATE_PROCESSED;
 694         index = buffer - channel->iob;
 695         prev = (index - 1) & (LCS_NUM_BUFFS - 1);
 696         next = (index + 1) & (LCS_NUM_BUFFS - 1);
 697         /* Set the suspend bit and clear the PCI bit of this buffer. */
 698         channel->ccws[index].flags |= CCW_FLAG_SUSPEND;
 699         channel->ccws[index].flags &= ~CCW_FLAG_PCI;
 700         /* Check the suspend bit of the previous buffer. */
 701         if (channel->iob[prev].state == LCS_BUF_STATE_READY) {
 702                 /*
 703                  * Previous buffer is in state ready. It might have
 704                  * happened in lcs_ready_buffer that the suspend bit
 705                  * has not been cleared to avoid an endless loop.
 706                  * Do it now.
 707                  */
 708                 __lcs_ready_buffer_bits(channel, prev);
 709         }
 710         /* Clear PCI bit of next buffer. */
 711         channel->ccws[next].flags &= ~CCW_FLAG_PCI;
 712         return __lcs_resume_channel(channel);
 713 }
 714
 715 /**
 716  * Put a processed buffer back to state empty.
 717  */
 718 static void
 719 lcs_release_buffer(struct lcs_channel *channel, struct lcs_buffer *buffer)
 720 {
 721         unsigned long flags;
 722
 723         LCS_DBF_TEXT(5, trace, "relbuff");
 724         BUG_ON(buffer->state != LCS_BUF_STATE_LOCKED &&
 725                buffer->state != LCS_BUF_STATE_PROCESSED);
 726         spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
 727         buffer->state = LCS_BUF_STATE_EMPTY;
 728         spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
 729 }
 730
 731 /**
 732  * Get buffer for a lan command.
 733  */
 734 static struct lcs_buffer *
 735 lcs_get_lancmd(struct lcs_card *card, int count)
 736 {
 737         struct lcs_buffer *buffer;
 738         struct lcs_cmd *cmd;
 739
 740         LCS_DBF_TEXT(4, trace, "getlncmd");
 741         /* Get buffer and wait if none is available. */
 742         wait_event(card->write.wait_q,
 743                    ((buffer = lcs_get_buffer(&card->write)) != NULL));
 744         count += sizeof(struct lcs_header);
 745         *(__u16 *)(buffer->data + count) = 0;
 746         buffer->count = count + sizeof(__u16);
 747         buffer->callback = lcs_release_buffer;
 748         cmd = (struct lcs_cmd *) buffer->data;
 749         cmd->offset = count;
 750         cmd->type = LCS_FRAME_TYPE_CONTROL;
 751         cmd->slot = 0;
 752         return buffer;
 753 }
 754
 755
 756 static void
 757 lcs_get_reply(struct lcs_reply *reply)
 758 {
 759         refcount_inc(&reply->refcnt);
 760 }
 761
 762 static void
 763 lcs_put_reply(struct lcs_reply *reply)
 764 {
 765         if (refcount_dec_and_test(&reply->refcnt))
 766                 kfree(reply);
 767 }
 768
 769 static struct lcs_reply *
 770 lcs_alloc_reply(struct lcs_cmd *cmd)
 771 {
 772         struct lcs_reply *reply;
 773
 774         LCS_DBF_TEXT(4, trace, "getreply");
 775
 776         reply = kzalloc(sizeof(struct lcs_reply), GFP_ATOMIC);
 777         if (!reply)
 778                 return NULL;
 779         refcount_set(&reply->refcnt, 1);
 780         reply->sequence_no = cmd->sequence_no;
 781         reply->received = 0;
 782         reply->rc = 0;
 783         init_waitqueue_head(&reply->wait_q);
 784
 785         return reply;
 786 }
 787
 788 /**
 789  * Notifier function for lancmd replies. Called from read irq.
 790  */
 791 static void
 792 lcs_notify_lancmd_waiters(struct lcs_card *card, struct lcs_cmd *cmd)
 793 {
 794         struct list_head *l, *n;
 795         struct lcs_reply *reply;
 796
 797         LCS_DBF_TEXT(4, trace, "notiwait");
 798         spin_lock(&card->lock);
 799         list_for_each_safe(l, n, &card->lancmd_waiters) {
 800                 reply = list_entry(l, struct lcs_reply, list);
 801                 if (reply->sequence_no == cmd->sequence_no) {
 802                         lcs_get_reply(reply);
 803                         list_del_init(&reply->list);
 804                         if (reply->callback != NULL)
 805                                 reply->callback(card, cmd);
 806                         reply->received = 1;
 807                         reply->rc = cmd->return_code;
 808                         wake_up(&reply->wait_q);
 809                         lcs_put_reply(reply);
 810                         break;
 811                 }
 812         }
 813         spin_unlock(&card->lock);
 814 }
 815
 816 /**
 817  * Emit buffer of a lan command.
 818  */
 819 static void
 820 lcs_lancmd_timeout(struct timer_list *t)
 821 {
 822         struct lcs_reply *reply = from_timer(reply, t, timer);
 823         struct lcs_reply *list_reply, *r;
 824         unsigned long flags;
 825
 826         LCS_DBF_TEXT(4, trace, "timeout");
 827         spin_lock_irqsave(&reply->card->lock, flags);
 828         list_for_each_entry_safe(list_reply, r,
 829                                  &reply->card->lancmd_waiters,list) {
 830                 if (reply == list_reply) {
 831                         lcs_get_reply(reply);
 832                         list_del_init(&reply->list);
 833                         spin_unlock_irqrestore(&reply->card->lock, flags);
 834                         reply->received = 1;
 835                         reply->rc = -ETIME;
 836                         wake_up(&reply->wait_q);
 837                         lcs_put_reply(reply);
 838                         return;
 839                 }
 840         }
 841         spin_unlock_irqrestore(&reply->card->lock, flags);
 842 }
 843
 844 static int
 845 lcs_send_lancmd(struct lcs_card *card, struct lcs_buffer *buffer,
 846                 void (*reply_callback)(struct lcs_card *, struct lcs_cmd *))
 847 {
 848         struct lcs_reply *reply;
 849         struct lcs_cmd *cmd;
 850         unsigned long flags;
 851         int rc;
 852
 853         LCS_DBF_TEXT(4, trace, "sendcmd");
 854         cmd = (struct lcs_cmd *) buffer->data;
 855         cmd->return_code = 0;
 856         cmd->sequence_no = card->sequence_no++;
 857         reply = lcs_alloc_reply(cmd);
 858         if (!reply)
 859                 return -ENOMEM;
 860         reply->callback = reply_callback;
 861         reply->card = card;
 862         spin_lock_irqsave(&card->lock, flags);
 863         list_add_tail(&reply->list, &card->lancmd_waiters);
 864         spin_unlock_irqrestore(&card->lock, flags);
 865
 866         buffer->callback = lcs_release_buffer;
 867         rc = lcs_ready_buffer(&card->write, buffer);
 868         if (rc)
 869                 return rc;
 870         timer_setup(&reply->timer, lcs_lancmd_timeout, 0);
 871         mod_timer(&reply->timer, jiffies + HZ * card->lancmd_timeout);
 872         wait_event(reply->wait_q, reply->received);
 873         del_timer_sync(&reply->timer);
 874         LCS_DBF_TEXT_(4, trace, "rc:%d",reply->rc);
 875         rc = reply->rc;
 876         lcs_put_reply(reply);
 877         return rc ? -EIO : 0;
 878 }
 879
 880 /**
 881  * LCS startup command
 882  */
 883 static int
 884 lcs_send_startup(struct lcs_card *card, __u8 initiator)
 885 {
 886         struct lcs_buffer *buffer;
 887         struct lcs_cmd *cmd;
 888
 889         LCS_DBF_TEXT(2, trace, "startup");
 890         buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
 891         cmd = (struct lcs_cmd *) buffer->data;
 892         cmd->cmd_code = LCS_CMD_STARTUP;
 893         cmd->initiator = initiator;
 894         cmd->cmd.lcs_startup.buff_size = LCS_IOBUFFERSIZE;
 895         return lcs_send_lancmd(card, buffer, NULL);
 896 }
 897
 898 /**
 899  * LCS shutdown command
 900  */
 901 static int
 902 lcs_send_shutdown(struct lcs_card *card)
 903 {
 904         struct lcs_buffer *buffer;
 905         struct lcs_cmd *cmd;
 906
 907         LCS_DBF_TEXT(2, trace, "shutdown");
 908         buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
 909         cmd = (struct lcs_cmd *) buffer->data;
 910         cmd->cmd_code = LCS_CMD_SHUTDOWN;
 911         cmd->initiator = LCS_INITIATOR_TCPIP;
 912         return lcs_send_lancmd(card, buffer, NULL);
 913 }
 914
 915 /**
 916  * LCS lanstat command
 917  */
 918 static void
 919 __lcs_lanstat_cb(struct lcs_card *card, struct lcs_cmd *cmd)
 920 {
 921         LCS_DBF_TEXT(2, trace, "statcb");
 922         memcpy(card->mac, cmd->cmd.lcs_lanstat_cmd.mac_addr, LCS_MAC_LENGTH);
 923 }
 924
 925 static int
 926 lcs_send_lanstat(struct lcs_card *card)
 927 {
 928         struct lcs_buffer *buffer;
 929         struct lcs_cmd *cmd;
 930
 931         LCS_DBF_TEXT(2,trace, "cmdstat");
 932         buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
 933         cmd = (struct lcs_cmd *) buffer->data;
 934         /* Setup lanstat command. */
 935         cmd->cmd_code = LCS_CMD_LANSTAT;
 936         cmd->initiator = LCS_INITIATOR_TCPIP;
 937         cmd->cmd.lcs_std_cmd.lan_type = card->lan_type;
 938         cmd->cmd.lcs_std_cmd.portno = card->portno;
 939         return lcs_send_lancmd(card, buffer, __lcs_lanstat_cb);
 940 }
 941
 942 /**
 943  * send stoplan command
 944  */
 945 static int
 946 lcs_send_stoplan(struct lcs_card *card, __u8 initiator)
 947 {
 948         struct lcs_buffer *buffer;
 949         struct lcs_cmd *cmd;
 950
 951         LCS_DBF_TEXT(2, trace, "cmdstpln");
 952         buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
 953         cmd = (struct lcs_cmd *) buffer->data;
 954         cmd->cmd_code = LCS_CMD_STOPLAN;
 955         cmd->initiator = initiator;
 956         cmd->cmd.lcs_std_cmd.lan_type = card->lan_type;
 957         cmd->cmd.lcs_std_cmd.portno = card->portno;
 958         return lcs_send_lancmd(card, buffer, NULL);
 959 }
 960
 961 /**
 962  * send startlan command
 963  */
 964 static void
 965 __lcs_send_startlan_cb(struct lcs_card *card, struct lcs_cmd *cmd)
 966 {
 967         LCS_DBF_TEXT(2, trace, "srtlancb");
 968         card->lan_type = cmd->cmd.lcs_std_cmd.lan_type;
 969         card->portno = cmd->cmd.lcs_std_cmd.portno;
 970 }
 971
 972 static int
 973 lcs_send_startlan(struct lcs_card *card, __u8 initiator)
 974 {
 975         struct lcs_buffer *buffer;
 976         struct lcs_cmd *cmd;
 977
 978         LCS_DBF_TEXT(2, trace, "cmdstaln");
 979         buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
 980         cmd = (struct lcs_cmd *) buffer->data;
 981         cmd->cmd_code = LCS_CMD_STARTLAN;
 982         cmd->initiator = initiator;
 983         cmd->cmd.lcs_std_cmd.lan_type = card->lan_type;
 984         cmd->cmd.lcs_std_cmd.portno = card->portno;
 985         return lcs_send_lancmd(card, buffer, __lcs_send_startlan_cb);
 986 }
 987
 988 #ifdef CONFIG_IP_MULTICAST
 989 /**
 990  * send setipm command (Multicast)
 991  */
 992 static int
 993 lcs_send_setipm(struct lcs_card *card,struct lcs_ipm_list *ipm_list)
 994 {
 995         struct lcs_buffer *buffer;
 996         struct lcs_cmd *cmd;
 997
 998         LCS_DBF_TEXT(2, trace, "cmdsetim");
 999         buffer = lcs_get_lancmd(card, LCS_MULTICAST_CMD_SIZE);
1000         cmd = (struct lcs_cmd *) buffer->data;
1001         cmd->cmd_code = LCS_CMD_SETIPM;
1002         cmd->initiator = LCS_INITIATOR_TCPIP;
1003         cmd->cmd.lcs_qipassist.lan_type = card->lan_type;
1004         cmd->cmd.lcs_qipassist.portno = card->portno;
1005         cmd->cmd.lcs_qipassist.version = 4;
1006         cmd->cmd.lcs_qipassist.num_ip_pairs = 1;
1007         memcpy(cmd->cmd.lcs_qipassist.lcs_ipass_ctlmsg.ip_mac_pair,
1008                &ipm_list->ipm, sizeof (struct lcs_ip_mac_pair));
1009         LCS_DBF_TEXT_(2, trace, "%x",ipm_list->ipm.ip_addr);
1010         return lcs_send_lancmd(card, buffer, NULL);
1011 }
1012
1013 /**
1014  * send delipm command (Multicast)
1015  */
1016 static int
1017 lcs_send_delipm(struct lcs_card *card,struct lcs_ipm_list *ipm_list)
1018 {
1019         struct lcs_buffer *buffer;
1020         struct lcs_cmd *cmd;
1021
1022         LCS_DBF_TEXT(2, trace, "cmddelim");
1023         buffer = lcs_get_lancmd(card, LCS_MULTICAST_CMD_SIZE);
1024         cmd = (struct lcs_cmd *) buffer->data;
1025         cmd->cmd_code = LCS_CMD_DELIPM;
1026         cmd->initiator = LCS_INITIATOR_TCPIP;
1027         cmd->cmd.lcs_qipassist.lan_type = card->lan_type;
1028         cmd->cmd.lcs_qipassist.portno = card->portno;
1029         cmd->cmd.lcs_qipassist.version = 4;
1030         cmd->cmd.lcs_qipassist.num_ip_pairs = 1;
1031         memcpy(cmd->cmd.lcs_qipassist.lcs_ipass_ctlmsg.ip_mac_pair,
1032                &ipm_list->ipm, sizeof (struct lcs_ip_mac_pair));
1033         LCS_DBF_TEXT_(2, trace, "%x",ipm_list->ipm.ip_addr);
1034         return lcs_send_lancmd(card, buffer, NULL);
1035 }
1036
1037 /**
1038  * check if multicast is supported by LCS
1039  */
1040 static void
1041 __lcs_check_multicast_cb(struct lcs_card *card, struct lcs_cmd *cmd)
1042 {
1043         LCS_DBF_TEXT(2, trace, "chkmccb");
1044         card->ip_assists_supported =
1045                 cmd->cmd.lcs_qipassist.ip_assists_supported;
1046         card->ip_assists_enabled =
1047                 cmd->cmd.lcs_qipassist.ip_assists_enabled;
1048 }
1049
1050 static int
1051 lcs_check_multicast_support(struct lcs_card *card)
1052 {
1053         struct lcs_buffer *buffer;
1054         struct lcs_cmd *cmd;
1055         int rc;
1056
1057         LCS_DBF_TEXT(2, trace, "cmdqipa");
1058         /* Send query ipassist. */
1059         buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
1060         cmd = (struct lcs_cmd *) buffer->data;
1061         cmd->cmd_code = LCS_CMD_QIPASSIST;
1062         cmd->initiator = LCS_INITIATOR_TCPIP;
1063         cmd->cmd.lcs_qipassist.lan_type = card->lan_type;
1064         cmd->cmd.lcs_qipassist.portno = card->portno;
1065         cmd->cmd.lcs_qipassist.version = 4;
1066         cmd->cmd.lcs_qipassist.num_ip_pairs = 1;
1067         rc = lcs_send_lancmd(card, buffer, __lcs_check_multicast_cb);
1068         if (rc != 0) {
1069                 pr_err("Query IPAssist failed. Assuming unsupported!\n");
1070                 return -EOPNOTSUPP;
1071         }
1072         if (card->ip_assists_supported & LCS_IPASS_MULTICAST_SUPPORT)
1073                 return 0;
1074         return -EOPNOTSUPP;
1075 }
1076
1077 /**
1078  * set or del multicast address on LCS card
1079  */
1080 static void
1081 lcs_fix_multicast_list(struct lcs_card *card)
1082 {
1083         struct list_head failed_list;
1084         struct lcs_ipm_list *ipm, *tmp;
1085         unsigned long flags;
1086         int rc;
1087
1088         LCS_DBF_TEXT(4,trace, "fixipm");
1089         INIT_LIST_HEAD(&failed_list);
1090         spin_lock_irqsave(&card->ipm_lock, flags);
1091 list_modified:
1092         list_for_each_entry_safe(ipm, tmp, &card->ipm_list, list){
1093                 switch (ipm->ipm_state) {
1094                 case LCS_IPM_STATE_SET_REQUIRED:
1095                         /* del from ipm_list so no one else can tamper with
1096                          * this entry */
1097                         list_del_init(&ipm->list);
1098                         spin_unlock_irqrestore(&card->ipm_lock, flags);
1099                         rc = lcs_send_setipm(card, ipm);
1100                         spin_lock_irqsave(&card->ipm_lock, flags);
1101                         if (rc) {
1102                                 pr_info("Adding multicast address failed."
1103                                         " Table possibly full!\n");
1104                                 /* store ipm in failed list -> will be added
1105                                  * to ipm_list again, so a retry will be done
1106                                  * during the next call of this function */
1107                                 list_add_tail(&ipm->list, &failed_list);
1108                         } else {
1109                                 ipm->ipm_state = LCS_IPM_STATE_ON_CARD;
1110                                 /* re-insert into ipm_list */
1111                                 list_add_tail(&ipm->list, &card->ipm_list);
1112                         }
1113                         goto list_modified;
1114                 case LCS_IPM_STATE_DEL_REQUIRED:
1115                         list_del(&ipm->list);
1116                         spin_unlock_irqrestore(&card->ipm_lock, flags);
1117                         lcs_send_delipm(card, ipm);
1118                         spin_lock_irqsave(&card->ipm_lock, flags);
1119                         kfree(ipm);
1120                         goto list_modified;
1121                 case LCS_IPM_STATE_ON_CARD:
1122                         break;
1123                 }
1124         }
1125         /* re-insert all entries from the failed_list into ipm_list */
1126         list_for_each_entry_safe(ipm, tmp, &failed_list, list)
1127                 list_move_tail(&ipm->list, &card->ipm_list);
1128
1129         spin_unlock_irqrestore(&card->ipm_lock, flags);
1130 }
1131
1132 /**
1133  * get mac address for the relevant Multicast address
1134  */
1135 static void
1136 lcs_get_mac_for_ipm(__be32 ipm, char *mac, struct net_device *dev)
1137 {
1138         LCS_DBF_TEXT(4,trace, "getmac");
1139         ip_eth_mc_map(ipm, mac);
1140 }
1141
1142 /**
1143  * function called by net device to handle multicast address relevant things
1144  */
1145 static void lcs_remove_mc_addresses(struct lcs_card *card,
1146                                     struct in_device *in4_dev)
1147 {
1148         struct ip_mc_list *im4;
1149         struct list_head *l;
1150         struct lcs_ipm_list *ipm;
1151         unsigned long flags;
1152         char buf[MAX_ADDR_LEN];
1153
1154         LCS_DBF_TEXT(4, trace, "remmclst");
1155         spin_lock_irqsave(&card->ipm_lock, flags);
1156         list_for_each(l, &card->ipm_list) {
1157                 ipm = list_entry(l, struct lcs_ipm_list, list);
1158                 for (im4 = rcu_dereference(in4_dev->mc_list);
1159                      im4 != NULL; im4 = rcu_dereference(im4->next_rcu)) {
1160                         lcs_get_mac_for_ipm(im4->multiaddr, buf, card->dev);
1161                         if ( (ipm->ipm.ip_addr == im4->multiaddr) &&
1162                              (memcmp(buf, &ipm->ipm.mac_addr,
1163                                      LCS_MAC_LENGTH) == 0) )
1164                                 break;
1165                 }
1166                 if (im4 == NULL)
1167                         ipm->ipm_state = LCS_IPM_STATE_DEL_REQUIRED;
1168         }
1169         spin_unlock_irqrestore(&card->ipm_lock, flags);
1170 }
1171
1172 static struct lcs_ipm_list *lcs_check_addr_entry(struct lcs_card *card,
1173                                                  struct ip_mc_list *im4,
1174                                                  char *buf)
1175 {
1176         struct lcs_ipm_list *tmp, *ipm = NULL;
1177         struct list_head *l;
1178         unsigned long flags;
1179
1180         LCS_DBF_TEXT(4, trace, "chkmcent");
1181         spin_lock_irqsave(&card->ipm_lock, flags);
1182         list_for_each(l, &card->ipm_list) {
1183                 tmp = list_entry(l, struct lcs_ipm_list, list);
1184                 if ( (tmp->ipm.ip_addr == im4->multiaddr) &&
1185                      (memcmp(buf, &tmp->ipm.mac_addr,
1186                              LCS_MAC_LENGTH) == 0) ) {
1187                         ipm = tmp;
1188                         break;
1189                 }
1190         }
1191         spin_unlock_irqrestore(&card->ipm_lock, flags);
1192         return ipm;
1193 }
1194
1195 static void lcs_set_mc_addresses(struct lcs_card *card,
1196                                  struct in_device *in4_dev)
1197 {
1198
1199         struct ip_mc_list *im4;
1200         struct lcs_ipm_list *ipm;
1201         char buf[MAX_ADDR_LEN];
1202         unsigned long flags;
1203
1204         LCS_DBF_TEXT(4, trace, "setmclst");
1205         for (im4 = rcu_dereference(in4_dev->mc_list); im4 != NULL;
1206              im4 = rcu_dereference(im4->next_rcu)) {
1207                 lcs_get_mac_for_ipm(im4->multiaddr, buf, card->dev);
1208                 ipm = lcs_check_addr_entry(card, im4, buf);
1209                 if (ipm != NULL)
1210                         continue;       /* Address already in list. */
1211                 ipm = kzalloc(sizeof(struct lcs_ipm_list), GFP_ATOMIC);
1212                 if (ipm == NULL) {
1213                         pr_info("Not enough memory to add"
1214                                 " new multicast entry!\n");
1215                         break;
1216                 }
1217                 memcpy(&ipm->ipm.mac_addr, buf, LCS_MAC_LENGTH);
1218                 ipm->ipm.ip_addr = im4->multiaddr;
1219                 ipm->ipm_state = LCS_IPM_STATE_SET_REQUIRED;
1220                 spin_lock_irqsave(&card->ipm_lock, flags);
1221                 LCS_DBF_HEX(2,trace,&ipm->ipm.ip_addr,4);
1222                 list_add(&ipm->list, &card->ipm_list);
1223                 spin_unlock_irqrestore(&card->ipm_lock, flags);
1224         }
1225 }
1226
1227 static int
1228 lcs_register_mc_addresses(void *data)
1229 {
1230         struct lcs_card *card;
1231         struct in_device *in4_dev;
1232
1233         card = (struct lcs_card *) data;
1234
1235         if (!lcs_do_run_thread(card, LCS_SET_MC_THREAD))
1236                 return 0;
1237         LCS_DBF_TEXT(4, trace, "regmulti");
1238
1239         in4_dev = in_dev_get(card->dev);
1240         if (in4_dev == NULL)
1241                 goto out;
1242         rcu_read_lock();
1243         lcs_remove_mc_addresses(card,in4_dev);
1244         lcs_set_mc_addresses(card, in4_dev);
1245         rcu_read_unlock();
1246         in_dev_put(in4_dev);
1247
1248         netif_carrier_off(card->dev);
1249         netif_tx_disable(card->dev);
1250         wait_event(card->write.wait_q,
1251                         (card->write.state != LCS_CH_STATE_RUNNING));
1252         lcs_fix_multicast_list(card);
1253         if (card->state == DEV_STATE_UP) {
1254                 netif_carrier_on(card->dev);
1255                 netif_wake_queue(card->dev);
1256         }
1257 out:
1258         lcs_clear_thread_running_bit(card, LCS_SET_MC_THREAD);
1259         return 0;
1260 }
1261 #endif /* CONFIG_IP_MULTICAST */
1262
1263 /**
1264  * function called by net device to
1265  * handle multicast address relevant things
1266  */
1267 static void
1268 lcs_set_multicast_list(struct net_device *dev)
1269 {
1270 #ifdef CONFIG_IP_MULTICAST
1271         struct lcs_card *card;
1272
1273         LCS_DBF_TEXT(4, trace, "setmulti");
1274         card = (struct lcs_card *) dev->ml_priv;
1275
1276         if (!lcs_set_thread_start_bit(card, LCS_SET_MC_THREAD))
1277                 schedule_work(&card->kernel_thread_starter);
1278 #endif /* CONFIG_IP_MULTICAST */
1279 }
1280
1281 static long
1282 lcs_check_irb_error(struct ccw_device *cdev, struct irb *irb)
1283 {
1284         if (!IS_ERR(irb))
1285                 return 0;
1286
1287         switch (PTR_ERR(irb)) {
1288         case -EIO:
1289                 dev_warn(&cdev->dev,
1290                         "An I/O-error occurred on the LCS device\n");
1291                 LCS_DBF_TEXT(2, trace, "ckirberr");
1292                 LCS_DBF_TEXT_(2, trace, "  rc%d", -EIO);
1293                 break;
1294         case -ETIMEDOUT:
1295                 dev_warn(&cdev->dev,
1296                         "A command timed out on the LCS device\n");
1297                 LCS_DBF_TEXT(2, trace, "ckirberr");
1298                 LCS_DBF_TEXT_(2, trace, "  rc%d", -ETIMEDOUT);
1299                 break;
1300         default:
1301                 dev_warn(&cdev->dev,
1302                         "An error occurred on the LCS device, rc=%ld\n",
1303                         PTR_ERR(irb));
1304                 LCS_DBF_TEXT(2, trace, "ckirberr");
1305                 LCS_DBF_TEXT(2, trace, "  rc???");
1306         }
1307         return PTR_ERR(irb);
1308 }
1309
1310 static int
1311 lcs_get_problem(struct ccw_device *cdev, struct irb *irb)
1312 {
1313         int dstat, cstat;
1314         char *sense;
1315
1316         sense = (char *) irb->ecw;
1317         cstat = irb->scsw.cmd.cstat;
1318         dstat = irb->scsw.cmd.dstat;
1319
1320         if (cstat & (SCHN_STAT_CHN_CTRL_CHK | SCHN_STAT_INTF_CTRL_CHK |
1321                      SCHN_STAT_CHN_DATA_CHK | SCHN_STAT_CHAIN_CHECK |
1322                      SCHN_STAT_PROT_CHECK   | SCHN_STAT_PROG_CHECK)) {
1323                 LCS_DBF_TEXT(2, trace, "CGENCHK");
1324                 return 1;
1325         }
1326         if (dstat & DEV_STAT_UNIT_CHECK) {
1327                 if (sense[LCS_SENSE_BYTE_1] &
1328                     LCS_SENSE_RESETTING_EVENT) {
1329                         LCS_DBF_TEXT(2, trace, "REVIND");
1330                         return 1;
1331                 }
1332                 if (sense[LCS_SENSE_BYTE_0] &
1333                     LCS_SENSE_CMD_REJECT) {
1334                         LCS_DBF_TEXT(2, trace, "CMDREJ");
1335                         return 0;
1336                 }
1337                 if ((!sense[LCS_SENSE_BYTE_0]) &&
1338                     (!sense[LCS_SENSE_BYTE_1]) &&
1339                     (!sense[LCS_SENSE_BYTE_2]) &&
1340                     (!sense[LCS_SENSE_BYTE_3])) {
1341                         LCS_DBF_TEXT(2, trace, "ZEROSEN");
1342                         return 0;
1343                 }
1344                 LCS_DBF_TEXT(2, trace, "DGENCHK");
1345                 return 1;
1346         }
1347         return 0;
1348 }
1349
1350 static void
1351 lcs_schedule_recovery(struct lcs_card *card)
1352 {
1353         LCS_DBF_TEXT(2, trace, "startrec");
1354         if (!lcs_set_thread_start_bit(card, LCS_RECOVERY_THREAD))
1355                 schedule_work(&card->kernel_thread_starter);
1356 }
1357
1358 /**
1359  * IRQ Handler for LCS channels
1360  */
1361 static void
1362 lcs_irq(struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
1363 {
1364         struct lcs_card *card;
1365         struct lcs_channel *channel;
1366         int rc, index;
1367         int cstat, dstat;
1368
1369         if (lcs_check_irb_error(cdev, irb))
1370                 return;
1371
1372         card = CARD_FROM_DEV(cdev);
1373         if (card->read.ccwdev == cdev)
1374                 channel = &card->read;
1375         else
1376                 channel = &card->write;
1377
1378         cstat = irb->scsw.cmd.cstat;
1379         dstat = irb->scsw.cmd.dstat;
1380         LCS_DBF_TEXT_(5, trace, "Rint%s", dev_name(&cdev->dev));
1381         LCS_DBF_TEXT_(5, trace, "%4x%4x", irb->scsw.cmd.cstat,
1382                       irb->scsw.cmd.dstat);
1383         LCS_DBF_TEXT_(5, trace, "%4x%4x", irb->scsw.cmd.fctl,
1384                       irb->scsw.cmd.actl);
1385
1386         /* Check for channel and device errors presented */
1387         rc = lcs_get_problem(cdev, irb);
1388         if (rc || (dstat & DEV_STAT_UNIT_EXCEP)) {
1389                 dev_warn(&cdev->dev,
1390                         "The LCS device stopped because of an error,"
1391                         " dstat=0x%X, cstat=0x%X \n",
1392                             dstat, cstat);
1393                 if (rc) {
1394                         channel->state = LCS_CH_STATE_ERROR;
1395                 }
1396         }
1397         if (channel->state == LCS_CH_STATE_ERROR) {
1398                 lcs_schedule_recovery(card);
1399                 wake_up(&card->wait_q);
1400                 return;
1401         }
1402         /* How far in the ccw chain have we processed? */
1403         if ((channel->state != LCS_CH_STATE_INIT) &&
1404             (irb->scsw.cmd.fctl & SCSW_FCTL_START_FUNC) &&
1405             (irb->scsw.cmd.cpa != 0)) {
1406                 index = (struct ccw1 *) __va((addr_t) irb->scsw.cmd.cpa)
1407                         - channel->ccws;
1408                 if ((irb->scsw.cmd.actl & SCSW_ACTL_SUSPENDED) ||
1409                     (irb->scsw.cmd.cstat & SCHN_STAT_PCI))
1410                         /* Bloody io subsystem tells us lies about cpa... */
1411                         index = (index - 1) & (LCS_NUM_BUFFS - 1);
1412                 while (channel->io_idx != index) {
1413                         __lcs_processed_buffer(channel,
1414                                                channel->iob + channel->io_idx);
1415                         channel->io_idx =
1416                                 (channel->io_idx + 1) & (LCS_NUM_BUFFS - 1);
1417                 }
1418         }
1419
1420         if ((irb->scsw.cmd.dstat & DEV_STAT_DEV_END) ||
1421             (irb->scsw.cmd.dstat & DEV_STAT_CHN_END) ||
1422             (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK))
1423                 /* Mark channel as stopped. */
1424                 channel->state = LCS_CH_STATE_STOPPED;
1425         else if (irb->scsw.cmd.actl & SCSW_ACTL_SUSPENDED)
1426                 /* CCW execution stopped on a suspend bit. */
1427                 channel->state = LCS_CH_STATE_SUSPENDED;
1428         if (irb->scsw.cmd.fctl & SCSW_FCTL_HALT_FUNC) {
1429                 if (irb->scsw.cmd.cc != 0) {
1430                         ccw_device_halt(channel->ccwdev, (addr_t) channel);
1431                         return;
1432                 }
1433                 /* The channel has been stopped by halt_IO. */
1434                 channel->state = LCS_CH_STATE_HALTED;
1435         }
1436         if (irb->scsw.cmd.fctl & SCSW_FCTL_CLEAR_FUNC)
1437                 channel->state = LCS_CH_STATE_CLEARED;
1438         /* Do the rest in the tasklet. */
1439         tasklet_schedule(&channel->irq_tasklet);
1440 }
1441
1442 /**
1443  * Tasklet for IRQ handler
1444  */
1445 static void
1446 lcs_tasklet(unsigned long data)
1447 {
1448         unsigned long flags;
1449         struct lcs_channel *channel;
1450         struct lcs_buffer *iob;
1451         int buf_idx;
1452
1453         channel = (struct lcs_channel *) data;
1454         LCS_DBF_TEXT_(5, trace, "tlet%s", dev_name(&channel->ccwdev->dev));
1455
1456         /* Check for processed buffers. */
1457         iob = channel->iob;
1458         buf_idx = channel->buf_idx;
1459         while (iob[buf_idx].state == LCS_BUF_STATE_PROCESSED) {
1460                 /* Do the callback thing. */
1461                 if (iob[buf_idx].callback != NULL)
1462                         iob[buf_idx].callback(channel, iob + buf_idx);
1463                 buf_idx = (buf_idx + 1) & (LCS_NUM_BUFFS - 1);
1464         }
1465         channel->buf_idx = buf_idx;
1466
1467         if (channel->state == LCS_CH_STATE_STOPPED)
1468                 lcs_start_channel(channel);
1469         spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
1470         if (channel->state == LCS_CH_STATE_SUSPENDED &&
1471             channel->iob[channel->io_idx].state == LCS_BUF_STATE_READY)
1472                 __lcs_resume_channel(channel);
1473         spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
1474
1475         /* Something happened on the channel. Wake up waiters. */
1476         wake_up(&channel->wait_q);
1477 }
1478
1479 /**
1480  * Finish current tx buffer and make it ready for transmit.
1481  */
1482 static void
1483 __lcs_emit_txbuffer(struct lcs_card *card)
1484 {
1485         LCS_DBF_TEXT(5, trace, "emittx");
1486         *(__u16 *)(card->tx_buffer->data + card->tx_buffer->count) = 0;
1487         card->tx_buffer->count += 2;
1488         lcs_ready_buffer(&card->write, card->tx_buffer);
1489         card->tx_buffer = NULL;
1490         card->tx_emitted++;
1491 }
1492
1493 /**
1494  * Callback for finished tx buffers.
1495  */
1496 static void
1497 lcs_txbuffer_cb(struct lcs_channel *channel, struct lcs_buffer *buffer)
1498 {
1499         struct lcs_card *card;
1500
1501         LCS_DBF_TEXT(5, trace, "txbuffcb");
1502         /* Put buffer back to pool. */
1503         lcs_release_buffer(channel, buffer);
1504         card = container_of(channel, struct lcs_card, write);
1505         if (netif_queue_stopped(card->dev) && netif_carrier_ok(card->dev))
1506                 netif_wake_queue(card->dev);
1507         spin_lock(&card->lock);
1508         card->tx_emitted--;
1509         if (card->tx_emitted <= 0 && card->tx_buffer != NULL)
1510                 /*
1511                  * Last running tx buffer has finished. Submit partially
1512                  * filled current buffer.
1513                  */
1514                 __lcs_emit_txbuffer(card);
1515         spin_unlock(&card->lock);
1516 }
1517
1518 /**
1519  * Packet transmit function called by network stack
1520  */
1521 static int
1522 __lcs_start_xmit(struct lcs_card *card, struct sk_buff *skb,
1523                  struct net_device *dev)
1524 {
1525         struct lcs_header *header;
1526         int rc = NETDEV_TX_OK;
1527
1528         LCS_DBF_TEXT(5, trace, "hardxmit");
1529         if (skb == NULL) {
1530                 card->stats.tx_dropped++;
1531                 card->stats.tx_errors++;
1532                 return NETDEV_TX_OK;
1533         }
1534         if (card->state != DEV_STATE_UP) {
1535                 dev_kfree_skb(skb);
1536                 card->stats.tx_dropped++;
1537                 card->stats.tx_errors++;
1538                 card->stats.tx_carrier_errors++;
1539                 return NETDEV_TX_OK;
1540         }
1541         if (skb->protocol == htons(ETH_P_IPV6)) {
1542                 dev_kfree_skb(skb);
1543                 return NETDEV_TX_OK;
1544         }
1545         netif_stop_queue(card->dev);
1546         spin_lock(&card->lock);
1547         if (card->tx_buffer != NULL &&
1548             card->tx_buffer->count + sizeof(struct lcs_header) +
1549             skb->len + sizeof(u16) > LCS_IOBUFFERSIZE)
1550                 /* skb too big for current tx buffer. */
1551                 __lcs_emit_txbuffer(card);
1552         if (card->tx_buffer == NULL) {
1553                 /* Get new tx buffer */
1554                 card->tx_buffer = lcs_get_buffer(&card->write);
1555                 if (card->tx_buffer == NULL) {
1556                         card->stats.tx_dropped++;
1557                         rc = NETDEV_TX_BUSY;
1558                         goto out;
1559                 }
1560                 card->tx_buffer->callback = lcs_txbuffer_cb;
1561                 card->tx_buffer->count = 0;
1562         }
1563         header = (struct lcs_header *)
1564                 (card->tx_buffer->data + card->tx_buffer->count);
1565         card->tx_buffer->count += skb->len + sizeof(struct lcs_header);
1566         header->offset = card->tx_buffer->count;
1567         header->type = card->lan_type;
1568         header->slot = card->portno;
1569         skb_copy_from_linear_data(skb, header + 1, skb->len);
1570         spin_unlock(&card->lock);
1571         card->stats.tx_bytes += skb->len;
1572         card->stats.tx_packets++;
1573         dev_kfree_skb(skb);
1574         netif_wake_queue(card->dev);
1575         spin_lock(&card->lock);
1576         if (card->tx_emitted <= 0 && card->tx_buffer != NULL)
1577                 /* If this is the first tx buffer emit it immediately. */
1578                 __lcs_emit_txbuffer(card);
1579 out:
1580         spin_unlock(&card->lock);
1581         return rc;
1582 }
1583
1584 static int
1585 lcs_start_xmit(struct sk_buff *skb, struct net_device *dev)
1586 {
1587         struct lcs_card *card;
1588         int rc;
1589
1590         LCS_DBF_TEXT(5, trace, "pktxmit");
1591         card = (struct lcs_card *) dev->ml_priv;
1592         rc = __lcs_start_xmit(card, skb, dev);
1593         return rc;
1594 }
1595
1596 /**
1597  * send startlan and lanstat command to make LCS device ready
1598  */
1599 static int
1600 lcs_startlan_auto(struct lcs_card *card)
1601 {
1602         int rc;
1603
1604         LCS_DBF_TEXT(2, trace, "strtauto");
1605 #ifdef CONFIG_ETHERNET
1606         card->lan_type = LCS_FRAME_TYPE_ENET;
1607         rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP);
1608         if (rc == 0)
1609                 return 0;
1610
1611 #endif
1612 #ifdef CONFIG_FDDI
1613         card->lan_type = LCS_FRAME_TYPE_FDDI;
1614         rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP);
1615         if (rc == 0)
1616                 return 0;
1617 #endif
1618         return -EIO;
1619 }
1620
1621 static int
1622 lcs_startlan(struct lcs_card *card)
1623 {
1624         int rc, i;
1625
1626         LCS_DBF_TEXT(2, trace, "startlan");
1627         rc = 0;
1628         if (card->portno != LCS_INVALID_PORT_NO) {
1629                 if (card->lan_type == LCS_FRAME_TYPE_AUTO)
1630                         rc = lcs_startlan_auto(card);
1631                 else
1632                         rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP);
1633         } else {
1634                 for (i = 0; i <= 16; i++) {
1635                         card->portno = i;
1636                         if (card->lan_type != LCS_FRAME_TYPE_AUTO)
1637                                 rc = lcs_send_startlan(card,
1638                                                        LCS_INITIATOR_TCPIP);
1639                         else
1640                                 /* autodetecting lan type */
1641                                 rc = lcs_startlan_auto(card);
1642                         if (rc == 0)
1643                                 break;
1644                 }
1645         }
1646         if (rc == 0)
1647                 return lcs_send_lanstat(card);
1648         return rc;
1649 }
1650
1651 /**
1652  * LCS detect function
1653  * setup channels and make them I/O ready
1654  */
1655 static int
1656 lcs_detect(struct lcs_card *card)
1657 {
1658         int rc = 0;
1659
1660         LCS_DBF_TEXT(2, setup, "lcsdetct");
1661         /* start/reset card */
1662         if (card->dev)
1663                 netif_stop_queue(card->dev);
1664         rc = lcs_stop_channels(card);
1665         if (rc == 0) {
1666                 rc = lcs_start_channels(card);
1667                 if (rc == 0) {
1668                         rc = lcs_send_startup(card, LCS_INITIATOR_TCPIP);
1669                         if (rc == 0)
1670                                 rc = lcs_startlan(card);
1671                 }
1672         }
1673         if (rc == 0) {
1674                 card->state = DEV_STATE_UP;
1675         } else {
1676                 card->state = DEV_STATE_DOWN;
1677                 card->write.state = LCS_CH_STATE_INIT;
1678                 card->read.state =  LCS_CH_STATE_INIT;
1679         }
1680         return rc;
1681 }
1682
1683 /**
1684  * LCS Stop card
1685  */
1686 static int
1687 lcs_stopcard(struct lcs_card *card)
1688 {
1689         int rc;
1690
1691         LCS_DBF_TEXT(3, setup, "stopcard");
1692
1693         if (card->read.state != LCS_CH_STATE_STOPPED &&
1694             card->write.state != LCS_CH_STATE_STOPPED &&
1695             card->read.state != LCS_CH_STATE_ERROR &&
1696             card->write.state != LCS_CH_STATE_ERROR &&
1697             card->state == DEV_STATE_UP) {
1698                 lcs_clear_multicast_list(card);
1699                 rc = lcs_send_stoplan(card,LCS_INITIATOR_TCPIP);
1700                 rc = lcs_send_shutdown(card);
1701         }
1702         rc = lcs_stop_channels(card);
1703         card->state = DEV_STATE_DOWN;
1704
1705         return rc;
1706 }
1707
1708 /**
1709  * Kernel Thread helper functions for LGW initiated commands
1710  */
1711 static void
1712 lcs_start_kernel_thread(struct work_struct *work)
1713 {
1714         struct lcs_card *card = container_of(work, struct lcs_card, kernel_thread_starter);
1715         LCS_DBF_TEXT(5, trace, "krnthrd");
1716         if (lcs_do_start_thread(card, LCS_RECOVERY_THREAD))
1717                 kthread_run(lcs_recovery, card, "lcs_recover");
1718 #ifdef CONFIG_IP_MULTICAST
1719         if (lcs_do_start_thread(card, LCS_SET_MC_THREAD))
1720                 kthread_run(lcs_register_mc_addresses, card, "regipm");
1721 #endif
1722 }
1723
1724 /**
1725  * Process control frames.
1726  */
1727 static void
1728 lcs_get_control(struct lcs_card *card, struct lcs_cmd *cmd)
1729 {
1730         LCS_DBF_TEXT(5, trace, "getctrl");
1731         if (cmd->initiator == LCS_INITIATOR_LGW) {
1732                 switch(cmd->cmd_code) {
1733                 case LCS_CMD_STARTUP:
1734                 case LCS_CMD_STARTLAN:
1735                         lcs_schedule_recovery(card);
1736                         break;
1737                 case LCS_CMD_STOPLAN:
1738                         pr_warn("Stoplan for %s initiated by LGW\n",
1739                                 card->dev->name);
1740                         if (card->dev)
1741                                 netif_carrier_off(card->dev);
1742                         break;
1743                 default:
1744                         LCS_DBF_TEXT(5, trace, "noLGWcmd");
1745                         break;
1746                 }
1747         } else
1748                 lcs_notify_lancmd_waiters(card, cmd);
1749 }
1750
1751 /**
1752  * Unpack network packet.
1753  */
1754 static void
1755 lcs_get_skb(struct lcs_card *card, char *skb_data, unsigned int skb_len)
1756 {
1757         struct sk_buff *skb;
1758
1759         LCS_DBF_TEXT(5, trace, "getskb");
1760         if (card->dev == NULL ||
1761             card->state != DEV_STATE_UP)
1762                 /* The card isn't up. Ignore the packet. */
1763                 return;
1764
1765         skb = dev_alloc_skb(skb_len);
1766         if (skb == NULL) {
1767                 dev_err(&card->dev->dev,
1768                         " Allocating a socket buffer to interface %s failed\n",
1769                           card->dev->name);
1770                 card->stats.rx_dropped++;
1771                 return;
1772         }
1773         skb_put_data(skb, skb_data, skb_len);
1774         skb->protocol = card->lan_type_trans(skb, card->dev);
1775         card->stats.rx_bytes += skb_len;
1776         card->stats.rx_packets++;
1777         if (skb->protocol == htons(ETH_P_802_2))
1778                 *((__u32 *)skb->cb) = ++card->pkt_seq;
1779         netif_rx(skb);
1780 }
1781
1782 /**
1783  * LCS main routine to get packets and lancmd replies from the buffers
1784  */
1785 static void
1786 lcs_get_frames_cb(struct lcs_channel *channel, struct lcs_buffer *buffer)
1787 {
1788         struct lcs_card *card;
1789         struct lcs_header *lcs_hdr;
1790         __u16 offset;
1791
1792         LCS_DBF_TEXT(5, trace, "lcsgtpkt");
1793         lcs_hdr = (struct lcs_header *) buffer->data;
1794         if (lcs_hdr->offset == LCS_ILLEGAL_OFFSET) {
1795                 LCS_DBF_TEXT(4, trace, "-eiogpkt");
1796                 return;
1797         }
1798         card = container_of(channel, struct lcs_card, read);
1799         offset = 0;
1800         while (lcs_hdr->offset != 0) {
1801                 if (lcs_hdr->offset <= 0 ||
1802                     lcs_hdr->offset > LCS_IOBUFFERSIZE ||
1803                     lcs_hdr->offset < offset) {
1804                         /* Offset invalid. */
1805                         card->stats.rx_length_errors++;
1806                         card->stats.rx_errors++;
1807                         return;
1808                 }
1809                 /* What kind of frame is it? */
1810                 if (lcs_hdr->type == LCS_FRAME_TYPE_CONTROL)
1811                         /* Control frame. */
1812                         lcs_get_control(card, (struct lcs_cmd *) lcs_hdr);
1813                 else if (lcs_hdr->type == LCS_FRAME_TYPE_ENET ||
1814                          lcs_hdr->type == LCS_FRAME_TYPE_TR ||
1815                          lcs_hdr->type == LCS_FRAME_TYPE_FDDI)
1816                         /* Normal network packet. */
1817                         lcs_get_skb(card, (char *)(lcs_hdr + 1),
1818                                     lcs_hdr->offset - offset -
1819                                     sizeof(struct lcs_header));
1820                 else
1821                         /* Unknown frame type. */
1822                         ; // FIXME: error message ?
1823                 /* Proceed to next frame. */
1824                 offset = lcs_hdr->offset;
1825                 lcs_hdr->offset = LCS_ILLEGAL_OFFSET;
1826                 lcs_hdr = (struct lcs_header *) (buffer->data + offset);
1827         }
1828         /* The buffer is now empty. Make it ready again. */
1829         lcs_ready_buffer(&card->read, buffer);
1830 }
1831
1832 /**
1833  * get network statistics for ifconfig and other user programs
1834  */
1835 static struct net_device_stats *
1836 lcs_getstats(struct net_device *dev)
1837 {
1838         struct lcs_card *card;
1839
1840         LCS_DBF_TEXT(4, trace, "netstats");
1841         card = (struct lcs_card *) dev->ml_priv;
1842         return &card->stats;
1843 }
1844
1845 /**
1846  * stop lcs device
1847  * This function will be called by user doing ifconfig xxx down
1848  */
1849 static int
1850 lcs_stop_device(struct net_device *dev)
1851 {
1852         struct lcs_card *card;
1853         int rc;
1854
1855         LCS_DBF_TEXT(2, trace, "stopdev");
1856         card   = (struct lcs_card *) dev->ml_priv;
1857         netif_carrier_off(dev);
1858         netif_tx_disable(dev);
1859         dev->flags &= ~IFF_UP;
1860         wait_event(card->write.wait_q,
1861                 (card->write.state != LCS_CH_STATE_RUNNING));
1862         rc = lcs_stopcard(card);
1863         if (rc)
1864                 dev_err(&card->dev->dev,
1865                         " Shutting down the LCS device failed\n");
1866         return rc;
1867 }
1868
1869 /**
1870  * start lcs device and make it runnable
1871  * This function will be called by user doing ifconfig xxx up
1872  */
1873 static int
1874 lcs_open_device(struct net_device *dev)
1875 {
1876         struct lcs_card *card;
1877         int rc;
1878
1879         LCS_DBF_TEXT(2, trace, "opendev");
1880         card = (struct lcs_card *) dev->ml_priv;
1881         /* initialize statistics */
1882         rc = lcs_detect(card);
1883         if (rc) {
1884                 pr_err("Error in opening device!\n");
1885
1886         } else {
1887                 dev->flags |= IFF_UP;
1888                 netif_carrier_on(dev);
1889                 netif_wake_queue(dev);
1890                 card->state = DEV_STATE_UP;
1891         }
1892         return rc;
1893 }
1894
1895 /**
1896  * show function for portno called by cat or similar things
1897  */
1898 static ssize_t
1899 lcs_portno_show (struct device *dev, struct device_attribute *attr, char *buf)
1900 {
1901         struct lcs_card *card;
1902
1903         card = dev_get_drvdata(dev);
1904
1905         if (!card)
1906                 return 0;
1907
1908         return sprintf(buf, "%d\n", card->portno);
1909 }
1910
1911 /**
1912  * store the value which is piped to file portno
1913  */
1914 static ssize_t
1915 lcs_portno_store (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1916 {
1917         struct lcs_card *card;
1918         int rc;
1919         s16 value;
1920
1921         card = dev_get_drvdata(dev);
1922
1923         if (!card)
1924                 return 0;
1925
1926         rc = kstrtos16(buf, 0, &value);
1927         if (rc)
1928                 return -EINVAL;
1929         /* TODO: sanity checks */
1930         card->portno = value;
1931         if (card->dev)
1932                 card->dev->dev_port = card->portno;
1933
1934         return count;
1935
1936 }
1937
1938 static DEVICE_ATTR(portno, 0644, lcs_portno_show, lcs_portno_store);
1939
1940 static const char *lcs_type[] = {
1941         "not a channel",
1942         "2216 parallel",
1943         "2216 channel",
1944         "OSA LCS card",
1945         "unknown channel type",
1946         "unsupported channel type",
1947 };
1948
1949 static ssize_t
1950 lcs_type_show(struct device *dev, struct device_attribute *attr, char *buf)
1951 {
1952         struct ccwgroup_device *cgdev;
1953
1954         cgdev = to_ccwgroupdev(dev);
1955         if (!cgdev)
1956                 return -ENODEV;
1957
1958         return sprintf(buf, "%s\n", lcs_type[cgdev->cdev[0]->id.driver_info]);
1959 }
1960
1961 static DEVICE_ATTR(type, 0444, lcs_type_show, NULL);
1962
1963 static ssize_t
1964 lcs_timeout_show(struct device *dev, struct device_attribute *attr, char *buf)
1965 {
1966         struct lcs_card *card;
1967
1968         card = dev_get_drvdata(dev);
1969
1970         return card ? sprintf(buf, "%u\n", card->lancmd_timeout) : 0;
1971 }
1972
1973 static ssize_t
1974 lcs_timeout_store (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1975 {
1976         struct lcs_card *card;
1977         unsigned int value;
1978         int rc;
1979
1980         card = dev_get_drvdata(dev);
1981
1982         if (!card)
1983                 return 0;
1984
1985         rc = kstrtouint(buf, 0, &value);
1986         if (rc)
1987                 return -EINVAL;
1988         /* TODO: sanity checks */
1989         card->lancmd_timeout = value;
1990
1991         return count;
1992
1993 }
1994
1995 static DEVICE_ATTR(lancmd_timeout, 0644, lcs_timeout_show, lcs_timeout_store);
1996
1997 static ssize_t
1998 lcs_dev_recover_store(struct device *dev, struct device_attribute *attr,
1999                       const char *buf, size_t count)
2000 {
2001         struct lcs_card *card = dev_get_drvdata(dev);
2002         char *tmp;
2003         int i;
2004
2005         if (!card)
2006                 return -EINVAL;
2007         if (card->state != DEV_STATE_UP)
2008                 return -EPERM;
2009         i = simple_strtoul(buf, &tmp, 16);
2010         if (i == 1)
2011                 lcs_schedule_recovery(card);
2012         return count;
2013 }
2014
2015 static DEVICE_ATTR(recover, 0200, NULL, lcs_dev_recover_store);
2016
2017 static struct attribute * lcs_attrs[] = {
2018         &dev_attr_portno.attr,
2019         &dev_attr_type.attr,
2020         &dev_attr_lancmd_timeout.attr,
2021         &dev_attr_recover.attr,
2022         NULL,
2023 };
2024 static struct attribute_group lcs_attr_group = {
2025         .attrs = lcs_attrs,
2026 };
2027 static const struct attribute_group *lcs_attr_groups[] = {
2028         &lcs_attr_group,
2029         NULL,
2030 };
2031 static const struct device_type lcs_devtype = {
2032         .name = "lcs",
2033         .groups = lcs_attr_groups,
2034 };
2035
2036 /**
2037  * lcs_probe_device is called on establishing a new ccwgroup_device.
2038  */
2039 static int
2040 lcs_probe_device(struct ccwgroup_device *ccwgdev)
2041 {
2042         struct lcs_card *card;
2043
2044         if (!get_device(&ccwgdev->dev))
2045                 return -ENODEV;
2046
2047         LCS_DBF_TEXT(2, setup, "add_dev");
2048         card = lcs_alloc_card();
2049         if (!card) {
2050                 LCS_DBF_TEXT_(2, setup, "  rc%d", -ENOMEM);
2051                 put_device(&ccwgdev->dev);
2052                 return -ENOMEM;
2053         }
2054         dev_set_drvdata(&ccwgdev->dev, card);
2055         ccwgdev->cdev[0]->handler = lcs_irq;
2056         ccwgdev->cdev[1]->handler = lcs_irq;
2057         card->gdev = ccwgdev;
2058         INIT_WORK(&card->kernel_thread_starter, lcs_start_kernel_thread);
2059         card->thread_start_mask = 0;
2060         card->thread_allowed_mask = 0;
2061         card->thread_running_mask = 0;
2062         ccwgdev->dev.type = &lcs_devtype;
2063
2064         return 0;
2065 }
2066
2067 static int
2068 lcs_register_netdev(struct ccwgroup_device *ccwgdev)
2069 {
2070         struct lcs_card *card;
2071
2072         LCS_DBF_TEXT(2, setup, "regnetdv");
2073         card = dev_get_drvdata(&ccwgdev->dev);
2074         if (card->dev->reg_state != NETREG_UNINITIALIZED)
2075                 return 0;
2076         SET_NETDEV_DEV(card->dev, &ccwgdev->dev);
2077         return register_netdev(card->dev);
2078 }
2079
2080 /**
2081  * lcs_new_device will be called by setting the group device online.
2082  */
2083 static const struct net_device_ops lcs_netdev_ops = {
2084         .ndo_open               = lcs_open_device,
2085         .ndo_stop               = lcs_stop_device,
2086         .ndo_get_stats          = lcs_getstats,
2087         .ndo_start_xmit         = lcs_start_xmit,
2088 };
2089
2090 static const struct net_device_ops lcs_mc_netdev_ops = {
2091         .ndo_open               = lcs_open_device,
2092         .ndo_stop               = lcs_stop_device,
2093         .ndo_get_stats          = lcs_getstats,
2094         .ndo_start_xmit         = lcs_start_xmit,
2095         .ndo_set_rx_mode        = lcs_set_multicast_list,
2096 };
2097
2098 static int
2099 lcs_new_device(struct ccwgroup_device *ccwgdev)
2100 {
2101         struct  lcs_card *card;
2102         struct net_device *dev=NULL;
2103         enum lcs_dev_states recover_state;
2104         int rc;
2105
2106         card = dev_get_drvdata(&ccwgdev->dev);
2107         if (!card)
2108                 return -ENODEV;
2109
2110         LCS_DBF_TEXT(2, setup, "newdev");
2111         LCS_DBF_HEX(3, setup, &card, sizeof(void*));
2112         card->read.ccwdev  = ccwgdev->cdev[0];
2113         card->write.ccwdev = ccwgdev->cdev[1];
2114
2115         recover_state = card->state;
2116         rc = ccw_device_set_online(card->read.ccwdev);
2117         if (rc)
2118                 goto out_err;
2119         rc = ccw_device_set_online(card->write.ccwdev);
2120         if (rc)
2121                 goto out_werr;
2122
2123         LCS_DBF_TEXT(3, setup, "lcsnewdv");
2124
2125         lcs_setup_card(card);
2126         rc = lcs_detect(card);
2127         if (rc) {
2128                 LCS_DBF_TEXT(2, setup, "dtctfail");
2129                 dev_err(&ccwgdev->dev,
2130                         "Detecting a network adapter for LCS devices"
2131                         " failed with rc=%d (0x%x)\n", rc, rc);
2132                 lcs_stopcard(card);
2133                 goto out;
2134         }
2135         if (card->dev) {
2136                 LCS_DBF_TEXT(2, setup, "samedev");
2137                 LCS_DBF_HEX(3, setup, &card, sizeof(void*));
2138                 goto netdev_out;
2139         }
2140         switch (card->lan_type) {
2141 #ifdef CONFIG_ETHERNET
2142         case LCS_FRAME_TYPE_ENET:
2143                 card->lan_type_trans = eth_type_trans;
2144                 dev = alloc_etherdev(0);
2145                 break;
2146 #endif
2147 #ifdef CONFIG_FDDI
2148         case LCS_FRAME_TYPE_FDDI:
2149                 card->lan_type_trans = fddi_type_trans;
2150                 dev = alloc_fddidev(0);
2151                 break;
2152 #endif
2153         default:
2154                 LCS_DBF_TEXT(3, setup, "errinit");
2155                 pr_err(" Initialization failed\n");
2156                 goto out;
2157         }
2158         if (!dev)
2159                 goto out;
2160         card->dev = dev;
2161         card->dev->ml_priv = card;
2162         card->dev->netdev_ops = &lcs_netdev_ops;
2163         card->dev->dev_port = card->portno;
2164         memcpy(card->dev->dev_addr, card->mac, LCS_MAC_LENGTH);
2165 #ifdef CONFIG_IP_MULTICAST
2166         if (!lcs_check_multicast_support(card))
2167                 card->dev->netdev_ops = &lcs_mc_netdev_ops;
2168 #endif
2169 netdev_out:
2170         lcs_set_allowed_threads(card,0xffffffff);
2171         if (recover_state == DEV_STATE_RECOVER) {
2172                 lcs_set_multicast_list(card->dev);
2173                 card->dev->flags |= IFF_UP;
2174                 netif_carrier_on(card->dev);
2175                 netif_wake_queue(card->dev);
2176                 card->state = DEV_STATE_UP;
2177         } else {
2178                 lcs_stopcard(card);
2179         }
2180
2181         if (lcs_register_netdev(ccwgdev) != 0)
2182                 goto out;
2183
2184         /* Print out supported assists: IPv6 */
2185         pr_info("LCS device %s %s IPv6 support\n", card->dev->name,
2186                 (card->ip_assists_supported & LCS_IPASS_IPV6_SUPPORT) ?
2187                 "with" : "without");
2188         /* Print out supported assist: Multicast */
2189         pr_info("LCS device %s %s Multicast support\n", card->dev->name,
2190                 (card->ip_assists_supported & LCS_IPASS_MULTICAST_SUPPORT) ?
2191                 "with" : "without");
2192         return 0;
2193 out:
2194
2195         ccw_device_set_offline(card->write.ccwdev);
2196 out_werr:
2197         ccw_device_set_offline(card->read.ccwdev);
2198 out_err:
2199         return -ENODEV;
2200 }
2201
2202 /**
2203  * lcs_shutdown_device, called when setting the group device offline.
2204  */
2205 static int
2206 __lcs_shutdown_device(struct ccwgroup_device *ccwgdev, int recovery_mode)
2207 {
2208         struct lcs_card *card;
2209         enum lcs_dev_states recover_state;
2210         int ret = 0, ret2 = 0, ret3 = 0;
2211
2212         LCS_DBF_TEXT(3, setup, "shtdndev");
2213         card = dev_get_drvdata(&ccwgdev->dev);
2214         if (!card)
2215                 return -ENODEV;
2216         if (recovery_mode == 0) {
2217                 lcs_set_allowed_threads(card, 0);
2218                 if (lcs_wait_for_threads(card, LCS_SET_MC_THREAD))
2219                         return -ERESTARTSYS;
2220         }
2221         LCS_DBF_HEX(3, setup, &card, sizeof(void*));
2222         recover_state = card->state;
2223
2224         ret = lcs_stop_device(card->dev);
2225         ret2 = ccw_device_set_offline(card->read.ccwdev);
2226         ret3 = ccw_device_set_offline(card->write.ccwdev);
2227         if (!ret)
2228                 ret = (ret2) ? ret2 : ret3;
2229         if (ret)
2230                 LCS_DBF_TEXT_(3, setup, "1err:%d", ret);
2231         if (recover_state == DEV_STATE_UP) {
2232                 card->state = DEV_STATE_RECOVER;
2233         }
2234         return 0;
2235 }
2236
2237 static int
2238 lcs_shutdown_device(struct ccwgroup_device *ccwgdev)
2239 {
2240         return __lcs_shutdown_device(ccwgdev, 0);
2241 }
2242
2243 /**
2244  * drive lcs recovery after startup and startlan initiated by Lan Gateway
2245  */
2246 static int
2247 lcs_recovery(void *ptr)
2248 {
2249         struct lcs_card *card;
2250         struct ccwgroup_device *gdev;
2251         int rc;
2252
2253         card = (struct lcs_card *) ptr;
2254
2255         LCS_DBF_TEXT(4, trace, "recover1");
2256         if (!lcs_do_run_thread(card, LCS_RECOVERY_THREAD))
2257                 return 0;
2258         LCS_DBF_TEXT(4, trace, "recover2");
2259         gdev = card->gdev;
2260         dev_warn(&gdev->dev,
2261                 "A recovery process has been started for the LCS device\n");
2262         rc = __lcs_shutdown_device(gdev, 1);
2263         rc = lcs_new_device(gdev);
2264         if (!rc)
2265                 pr_info("Device %s successfully recovered!\n",
2266                         card->dev->name);
2267         else
2268                 pr_info("Device %s could not be recovered!\n",
2269                         card->dev->name);
2270         lcs_clear_thread_running_bit(card, LCS_RECOVERY_THREAD);
2271         return 0;
2272 }
2273
2274 /**
2275  * lcs_remove_device, free buffers and card
2276  */
2277 static void
2278 lcs_remove_device(struct ccwgroup_device *ccwgdev)
2279 {
2280         struct lcs_card *card;
2281
2282         card = dev_get_drvdata(&ccwgdev->dev);
2283         if (!card)
2284                 return;
2285
2286         LCS_DBF_TEXT(3, setup, "remdev");
2287         LCS_DBF_HEX(3, setup, &card, sizeof(void*));
2288         if (ccwgdev->state == CCWGROUP_ONLINE) {
2289                 lcs_shutdown_device(ccwgdev);
2290         }
2291         if (card->dev)
2292                 unregister_netdev(card->dev);
2293         lcs_cleanup_card(card);
2294         lcs_free_card(card);
2295         dev_set_drvdata(&ccwgdev->dev, NULL);
2296         put_device(&ccwgdev->dev);
2297 }
2298
2299 static int lcs_pm_suspend(struct lcs_card *card)
2300 {
2301         if (card->dev)
2302                 netif_device_detach(card->dev);
2303         lcs_set_allowed_threads(card, 0);
2304         lcs_wait_for_threads(card, 0xffffffff);
2305         if (card->state != DEV_STATE_DOWN)
2306                 __lcs_shutdown_device(card->gdev, 1);
2307         return 0;
2308 }
2309
2310 static int lcs_pm_resume(struct lcs_card *card)
2311 {
2312         int rc = 0;
2313
2314         if (card->state == DEV_STATE_RECOVER)
2315                 rc = lcs_new_device(card->gdev);
2316         if (card->dev)
2317                 netif_device_attach(card->dev);
2318         if (rc) {
2319                 dev_warn(&card->gdev->dev, "The lcs device driver "
2320                         "failed to recover the device\n");
2321         }
2322         return rc;
2323 }
2324
2325 static int lcs_prepare(struct ccwgroup_device *gdev)
2326 {
2327         return 0;
2328 }
2329
2330 static void lcs_complete(struct ccwgroup_device *gdev)
2331 {
2332         return;
2333 }
2334
2335 static int lcs_freeze(struct ccwgroup_device *gdev)
2336 {
2337         struct lcs_card *card = dev_get_drvdata(&gdev->dev);
2338         return lcs_pm_suspend(card);
2339 }
2340
2341 static int lcs_thaw(struct ccwgroup_device *gdev)
2342 {
2343         struct lcs_card *card = dev_get_drvdata(&gdev->dev);
2344         return lcs_pm_resume(card);
2345 }
2346
2347 static int lcs_restore(struct ccwgroup_device *gdev)
2348 {
2349         struct lcs_card *card = dev_get_drvdata(&gdev->dev);
2350         return lcs_pm_resume(card);
2351 }
2352
2353 static struct ccw_device_id lcs_ids[] = {
2354         {CCW_DEVICE(0x3088, 0x08), .driver_info = lcs_channel_type_parallel},
2355         {CCW_DEVICE(0x3088, 0x1f), .driver_info = lcs_channel_type_2216},
2356         {CCW_DEVICE(0x3088, 0x60), .driver_info = lcs_channel_type_osa2},
2357         {},
2358 };
2359 MODULE_DEVICE_TABLE(ccw, lcs_ids);
2360
2361 static struct ccw_driver lcs_ccw_driver = {
2362         .driver = {
2363                 .owner  = THIS_MODULE,
2364                 .name   = "lcs",
2365         },
2366         .ids    = lcs_ids,
2367         .probe  = ccwgroup_probe_ccwdev,
2368         .remove = ccwgroup_remove_ccwdev,
2369         .int_class = IRQIO_LCS,
2370 };
2371
2372 /**
2373  * LCS ccwgroup driver registration
2374  */
2375 static struct ccwgroup_driver lcs_group_driver = {
2376         .driver = {
2377                 .owner  = THIS_MODULE,
2378                 .name   = "lcs",
2379         },
2380         .ccw_driver  = &lcs_ccw_driver,
2381         .setup       = lcs_probe_device,
2382         .remove      = lcs_remove_device,
2383         .set_online  = lcs_new_device,
2384         .set_offline = lcs_shutdown_device,
2385         .prepare     = lcs_prepare,
2386         .complete    = lcs_complete,
2387         .freeze      = lcs_freeze,
2388         .thaw        = lcs_thaw,
2389         .restore     = lcs_restore,
2390 };
2391
2392 static ssize_t group_store(struct device_driver *ddrv, const char *buf,
2393                            size_t count)
2394 {
2395         int err;
2396         err = ccwgroup_create_dev(lcs_root_dev, &lcs_group_driver, 2, buf);
2397         return err ? err : count;
2398 }
2399 static DRIVER_ATTR_WO(group);
2400
2401 static struct attribute *lcs_drv_attrs[] = {
2402         &driver_attr_group.attr,
2403         NULL,
2404 };
2405 static struct attribute_group lcs_drv_attr_group = {
2406         .attrs = lcs_drv_attrs,
2407 };
2408 static const struct attribute_group *lcs_drv_attr_groups[] = {
2409         &lcs_drv_attr_group,
2410         NULL,
2411 };
2412
2413 /**
2414  *  LCS Module/Kernel initialization function
2415  */
2416 static int
2417 __init lcs_init_module(void)
2418 {
2419         int rc;
2420
2421         pr_info("Loading %s\n", version);
2422         rc = lcs_register_debug_facility();
2423         LCS_DBF_TEXT(0, setup, "lcsinit");
2424         if (rc)
2425                 goto out_err;
2426         lcs_root_dev = root_device_register("lcs");
2427         rc = PTR_ERR_OR_ZERO(lcs_root_dev);
2428         if (rc)
2429                 goto register_err;
2430         rc = ccw_driver_register(&lcs_ccw_driver);
2431         if (rc)
2432                 goto ccw_err;
2433         lcs_group_driver.driver.groups = lcs_drv_attr_groups;
2434         rc = ccwgroup_driver_register(&lcs_group_driver);
2435         if (rc)
2436                 goto ccwgroup_err;
2437         return 0;
2438
2439 ccwgroup_err:
2440         ccw_driver_unregister(&lcs_ccw_driver);
2441 ccw_err:
2442         root_device_unregister(lcs_root_dev);
2443 register_err:
2444         lcs_unregister_debug_facility();
2445 out_err:
2446         pr_err("Initializing the lcs device driver failed\n");
2447         return rc;
2448 }
2449
2450
2451 /**
2452  *  LCS module cleanup function
2453  */
2454 static void
2455 __exit lcs_cleanup_module(void)
2456 {
2457         pr_info("Terminating lcs module.\n");
2458         LCS_DBF_TEXT(0, trace, "cleanup");
2459         ccwgroup_driver_unregister(&lcs_group_driver);
2460         ccw_driver_unregister(&lcs_ccw_driver);
2461         root_device_unregister(lcs_root_dev);
2462         lcs_unregister_debug_facility();
2463 }
2464
2465 module_init(lcs_init_module);
2466 module_exit(lcs_cleanup_module);
2467
2468 MODULE_AUTHOR("Frank Pavlic <fpavlic@de.ibm.com>");
2469 MODULE_LICENSE("GPL");
2470