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         WARN_ON(atomic_read(&reply->refcnt) <= 0);
 760         atomic_inc(&reply->refcnt);
 761 }
 762
 763 static void
 764 lcs_put_reply(struct lcs_reply *reply)
 765 {
 766         WARN_ON(atomic_read(&reply->refcnt) <= 0);
 767         if (atomic_dec_and_test(&reply->refcnt)) {
 768                 kfree(reply);
 769         }
 770
 771 }
 772
 773 static struct lcs_reply *
 774 lcs_alloc_reply(struct lcs_cmd *cmd)
 775 {
 776         struct lcs_reply *reply;
 777
 778         LCS_DBF_TEXT(4, trace, "getreply");
 779
 780         reply = kzalloc(sizeof(struct lcs_reply), GFP_ATOMIC);
 781         if (!reply)
 782                 return NULL;
 783         atomic_set(&reply->refcnt,1);
 784         reply->sequence_no = cmd->sequence_no;
 785         reply->received = 0;
 786         reply->rc = 0;
 787         init_waitqueue_head(&reply->wait_q);
 788
 789         return reply;
 790 }
 791
 792 /**
 793  * Notifier function for lancmd replies. Called from read irq.
 794  */
 795 static void
 796 lcs_notify_lancmd_waiters(struct lcs_card *card, struct lcs_cmd *cmd)
 797 {
 798         struct list_head *l, *n;
 799         struct lcs_reply *reply;
 800
 801         LCS_DBF_TEXT(4, trace, "notiwait");
 802         spin_lock(&card->lock);
 803         list_for_each_safe(l, n, &card->lancmd_waiters) {
 804                 reply = list_entry(l, struct lcs_reply, list);
 805                 if (reply->sequence_no == cmd->sequence_no) {
 806                         lcs_get_reply(reply);
 807                         list_del_init(&reply->list);
 808                         if (reply->callback != NULL)
 809                                 reply->callback(card, cmd);
 810                         reply->received = 1;
 811                         reply->rc = cmd->return_code;
 812                         wake_up(&reply->wait_q);
 813                         lcs_put_reply(reply);
 814                         break;
 815                 }
 816         }
 817         spin_unlock(&card->lock);
 818 }
 819
 820 /**
 821  * Emit buffer of a lan command.
 822  */
 823 static void
 824 lcs_lancmd_timeout(struct timer_list *t)
 825 {
 826         struct lcs_reply *reply = from_timer(reply, t, timer);
 827         struct lcs_reply *list_reply, *r;
 828         unsigned long flags;
 829
 830         LCS_DBF_TEXT(4, trace, "timeout");
 831         spin_lock_irqsave(&reply->card->lock, flags);
 832         list_for_each_entry_safe(list_reply, r,
 833                                  &reply->card->lancmd_waiters,list) {
 834                 if (reply == list_reply) {
 835                         lcs_get_reply(reply);
 836                         list_del_init(&reply->list);
 837                         spin_unlock_irqrestore(&reply->card->lock, flags);
 838                         reply->received = 1;
 839                         reply->rc = -ETIME;
 840                         wake_up(&reply->wait_q);
 841                         lcs_put_reply(reply);
 842                         return;
 843                 }
 844         }
 845         spin_unlock_irqrestore(&reply->card->lock, flags);
 846 }
 847
 848 static int
 849 lcs_send_lancmd(struct lcs_card *card, struct lcs_buffer *buffer,
 850                 void (*reply_callback)(struct lcs_card *, struct lcs_cmd *))
 851 {
 852         struct lcs_reply *reply;
 853         struct lcs_cmd *cmd;
 854         unsigned long flags;
 855         int rc;
 856
 857         LCS_DBF_TEXT(4, trace, "sendcmd");
 858         cmd = (struct lcs_cmd *) buffer->data;
 859         cmd->return_code = 0;
 860         cmd->sequence_no = card->sequence_no++;
 861         reply = lcs_alloc_reply(cmd);
 862         if (!reply)
 863                 return -ENOMEM;
 864         reply->callback = reply_callback;
 865         reply->card = card;
 866         spin_lock_irqsave(&card->lock, flags);
 867         list_add_tail(&reply->list, &card->lancmd_waiters);
 868         spin_unlock_irqrestore(&card->lock, flags);
 869
 870         buffer->callback = lcs_release_buffer;
 871         rc = lcs_ready_buffer(&card->write, buffer);
 872         if (rc)
 873                 return rc;
 874         timer_setup(&reply->timer, lcs_lancmd_timeout, 0);
 875         mod_timer(&reply->timer, jiffies + HZ * card->lancmd_timeout);
 876         wait_event(reply->wait_q, reply->received);
 877         del_timer_sync(&reply->timer);
 878         LCS_DBF_TEXT_(4, trace, "rc:%d",reply->rc);
 879         rc = reply->rc;
 880         lcs_put_reply(reply);
 881         return rc ? -EIO : 0;
 882 }
 883
 884 /**
 885  * LCS startup command
 886  */
 887 static int
 888 lcs_send_startup(struct lcs_card *card, __u8 initiator)
 889 {
 890         struct lcs_buffer *buffer;
 891         struct lcs_cmd *cmd;
 892
 893         LCS_DBF_TEXT(2, trace, "startup");
 894         buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
 895         cmd = (struct lcs_cmd *) buffer->data;
 896         cmd->cmd_code = LCS_CMD_STARTUP;
 897         cmd->initiator = initiator;
 898         cmd->cmd.lcs_startup.buff_size = LCS_IOBUFFERSIZE;
 899         return lcs_send_lancmd(card, buffer, NULL);
 900 }
 901
 902 /**
 903  * LCS shutdown command
 904  */
 905 static int
 906 lcs_send_shutdown(struct lcs_card *card)
 907 {
 908         struct lcs_buffer *buffer;
 909         struct lcs_cmd *cmd;
 910
 911         LCS_DBF_TEXT(2, trace, "shutdown");
 912         buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
 913         cmd = (struct lcs_cmd *) buffer->data;
 914         cmd->cmd_code = LCS_CMD_SHUTDOWN;
 915         cmd->initiator = LCS_INITIATOR_TCPIP;
 916         return lcs_send_lancmd(card, buffer, NULL);
 917 }
 918
 919 /**
 920  * LCS lanstat command
 921  */
 922 static void
 923 __lcs_lanstat_cb(struct lcs_card *card, struct lcs_cmd *cmd)
 924 {
 925         LCS_DBF_TEXT(2, trace, "statcb");
 926         memcpy(card->mac, cmd->cmd.lcs_lanstat_cmd.mac_addr, LCS_MAC_LENGTH);
 927 }
 928
 929 static int
 930 lcs_send_lanstat(struct lcs_card *card)
 931 {
 932         struct lcs_buffer *buffer;
 933         struct lcs_cmd *cmd;
 934
 935         LCS_DBF_TEXT(2,trace, "cmdstat");
 936         buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
 937         cmd = (struct lcs_cmd *) buffer->data;
 938         /* Setup lanstat command. */
 939         cmd->cmd_code = LCS_CMD_LANSTAT;
 940         cmd->initiator = LCS_INITIATOR_TCPIP;
 941         cmd->cmd.lcs_std_cmd.lan_type = card->lan_type;
 942         cmd->cmd.lcs_std_cmd.portno = card->portno;
 943         return lcs_send_lancmd(card, buffer, __lcs_lanstat_cb);
 944 }
 945
 946 /**
 947  * send stoplan command
 948  */
 949 static int
 950 lcs_send_stoplan(struct lcs_card *card, __u8 initiator)
 951 {
 952         struct lcs_buffer *buffer;
 953         struct lcs_cmd *cmd;
 954
 955         LCS_DBF_TEXT(2, trace, "cmdstpln");
 956         buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
 957         cmd = (struct lcs_cmd *) buffer->data;
 958         cmd->cmd_code = LCS_CMD_STOPLAN;
 959         cmd->initiator = initiator;
 960         cmd->cmd.lcs_std_cmd.lan_type = card->lan_type;
 961         cmd->cmd.lcs_std_cmd.portno = card->portno;
 962         return lcs_send_lancmd(card, buffer, NULL);
 963 }
 964
 965 /**
 966  * send startlan command
 967  */
 968 static void
 969 __lcs_send_startlan_cb(struct lcs_card *card, struct lcs_cmd *cmd)
 970 {
 971         LCS_DBF_TEXT(2, trace, "srtlancb");
 972         card->lan_type = cmd->cmd.lcs_std_cmd.lan_type;
 973         card->portno = cmd->cmd.lcs_std_cmd.portno;
 974 }
 975
 976 static int
 977 lcs_send_startlan(struct lcs_card *card, __u8 initiator)
 978 {
 979         struct lcs_buffer *buffer;
 980         struct lcs_cmd *cmd;
 981
 982         LCS_DBF_TEXT(2, trace, "cmdstaln");
 983         buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
 984         cmd = (struct lcs_cmd *) buffer->data;
 985         cmd->cmd_code = LCS_CMD_STARTLAN;
 986         cmd->initiator = initiator;
 987         cmd->cmd.lcs_std_cmd.lan_type = card->lan_type;
 988         cmd->cmd.lcs_std_cmd.portno = card->portno;
 989         return lcs_send_lancmd(card, buffer, __lcs_send_startlan_cb);
 990 }
 991
 992 #ifdef CONFIG_IP_MULTICAST
 993 /**
 994  * send setipm command (Multicast)
 995  */
 996 static int
 997 lcs_send_setipm(struct lcs_card *card,struct lcs_ipm_list *ipm_list)
 998 {
 999         struct lcs_buffer *buffer;
1000         struct lcs_cmd *cmd;
1001
1002         LCS_DBF_TEXT(2, trace, "cmdsetim");
1003         buffer = lcs_get_lancmd(card, LCS_MULTICAST_CMD_SIZE);
1004         cmd = (struct lcs_cmd *) buffer->data;
1005         cmd->cmd_code = LCS_CMD_SETIPM;
1006         cmd->initiator = LCS_INITIATOR_TCPIP;
1007         cmd->cmd.lcs_qipassist.lan_type = card->lan_type;
1008         cmd->cmd.lcs_qipassist.portno = card->portno;
1009         cmd->cmd.lcs_qipassist.version = 4;
1010         cmd->cmd.lcs_qipassist.num_ip_pairs = 1;
1011         memcpy(cmd->cmd.lcs_qipassist.lcs_ipass_ctlmsg.ip_mac_pair,
1012                &ipm_list->ipm, sizeof (struct lcs_ip_mac_pair));
1013         LCS_DBF_TEXT_(2, trace, "%x",ipm_list->ipm.ip_addr);
1014         return lcs_send_lancmd(card, buffer, NULL);
1015 }
1016
1017 /**
1018  * send delipm command (Multicast)
1019  */
1020 static int
1021 lcs_send_delipm(struct lcs_card *card,struct lcs_ipm_list *ipm_list)
1022 {
1023         struct lcs_buffer *buffer;
1024         struct lcs_cmd *cmd;
1025
1026         LCS_DBF_TEXT(2, trace, "cmddelim");
1027         buffer = lcs_get_lancmd(card, LCS_MULTICAST_CMD_SIZE);
1028         cmd = (struct lcs_cmd *) buffer->data;
1029         cmd->cmd_code = LCS_CMD_DELIPM;
1030         cmd->initiator = LCS_INITIATOR_TCPIP;
1031         cmd->cmd.lcs_qipassist.lan_type = card->lan_type;
1032         cmd->cmd.lcs_qipassist.portno = card->portno;
1033         cmd->cmd.lcs_qipassist.version = 4;
1034         cmd->cmd.lcs_qipassist.num_ip_pairs = 1;
1035         memcpy(cmd->cmd.lcs_qipassist.lcs_ipass_ctlmsg.ip_mac_pair,
1036                &ipm_list->ipm, sizeof (struct lcs_ip_mac_pair));
1037         LCS_DBF_TEXT_(2, trace, "%x",ipm_list->ipm.ip_addr);
1038         return lcs_send_lancmd(card, buffer, NULL);
1039 }
1040
1041 /**
1042  * check if multicast is supported by LCS
1043  */
1044 static void
1045 __lcs_check_multicast_cb(struct lcs_card *card, struct lcs_cmd *cmd)
1046 {
1047         LCS_DBF_TEXT(2, trace, "chkmccb");
1048         card->ip_assists_supported =
1049                 cmd->cmd.lcs_qipassist.ip_assists_supported;
1050         card->ip_assists_enabled =
1051                 cmd->cmd.lcs_qipassist.ip_assists_enabled;
1052 }
1053
1054 static int
1055 lcs_check_multicast_support(struct lcs_card *card)
1056 {
1057         struct lcs_buffer *buffer;
1058         struct lcs_cmd *cmd;
1059         int rc;
1060
1061         LCS_DBF_TEXT(2, trace, "cmdqipa");
1062         /* Send query ipassist. */
1063         buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
1064         cmd = (struct lcs_cmd *) buffer->data;
1065         cmd->cmd_code = LCS_CMD_QIPASSIST;
1066         cmd->initiator = LCS_INITIATOR_TCPIP;
1067         cmd->cmd.lcs_qipassist.lan_type = card->lan_type;
1068         cmd->cmd.lcs_qipassist.portno = card->portno;
1069         cmd->cmd.lcs_qipassist.version = 4;
1070         cmd->cmd.lcs_qipassist.num_ip_pairs = 1;
1071         rc = lcs_send_lancmd(card, buffer, __lcs_check_multicast_cb);
1072         if (rc != 0) {
1073                 pr_err("Query IPAssist failed. Assuming unsupported!\n");
1074                 return -EOPNOTSUPP;
1075         }
1076         if (card->ip_assists_supported & LCS_IPASS_MULTICAST_SUPPORT)
1077                 return 0;
1078         return -EOPNOTSUPP;
1079 }
1080
1081 /**
1082  * set or del multicast address on LCS card
1083  */
1084 static void
1085 lcs_fix_multicast_list(struct lcs_card *card)
1086 {
1087         struct list_head failed_list;
1088         struct lcs_ipm_list *ipm, *tmp;
1089         unsigned long flags;
1090         int rc;
1091
1092         LCS_DBF_TEXT(4,trace, "fixipm");
1093         INIT_LIST_HEAD(&failed_list);
1094         spin_lock_irqsave(&card->ipm_lock, flags);
1095 list_modified:
1096         list_for_each_entry_safe(ipm, tmp, &card->ipm_list, list){
1097                 switch (ipm->ipm_state) {
1098                 case LCS_IPM_STATE_SET_REQUIRED:
1099                         /* del from ipm_list so no one else can tamper with
1100                          * this entry */
1101                         list_del_init(&ipm->list);
1102                         spin_unlock_irqrestore(&card->ipm_lock, flags);
1103                         rc = lcs_send_setipm(card, ipm);
1104                         spin_lock_irqsave(&card->ipm_lock, flags);
1105                         if (rc) {
1106                                 pr_info("Adding multicast address failed."
1107                                         " Table possibly full!\n");
1108                                 /* store ipm in failed list -> will be added
1109                                  * to ipm_list again, so a retry will be done
1110                                  * during the next call of this function */
1111                                 list_add_tail(&ipm->list, &failed_list);
1112                         } else {
1113                                 ipm->ipm_state = LCS_IPM_STATE_ON_CARD;
1114                                 /* re-insert into ipm_list */
1115                                 list_add_tail(&ipm->list, &card->ipm_list);
1116                         }
1117                         goto list_modified;
1118                 case LCS_IPM_STATE_DEL_REQUIRED:
1119                         list_del(&ipm->list);
1120                         spin_unlock_irqrestore(&card->ipm_lock, flags);
1121                         lcs_send_delipm(card, ipm);
1122                         spin_lock_irqsave(&card->ipm_lock, flags);
1123                         kfree(ipm);
1124                         goto list_modified;
1125                 case LCS_IPM_STATE_ON_CARD:
1126                         break;
1127                 }
1128         }
1129         /* re-insert all entries from the failed_list into ipm_list */
1130         list_for_each_entry_safe(ipm, tmp, &failed_list, list)
1131                 list_move_tail(&ipm->list, &card->ipm_list);
1132
1133         spin_unlock_irqrestore(&card->ipm_lock, flags);
1134 }
1135
1136 /**
1137  * get mac address for the relevant Multicast address
1138  */
1139 static void
1140 lcs_get_mac_for_ipm(__be32 ipm, char *mac, struct net_device *dev)
1141 {
1142         LCS_DBF_TEXT(4,trace, "getmac");
1143         ip_eth_mc_map(ipm, mac);
1144 }
1145
1146 /**
1147  * function called by net device to handle multicast address relevant things
1148  */
1149 static void lcs_remove_mc_addresses(struct lcs_card *card,
1150                                     struct in_device *in4_dev)
1151 {
1152         struct ip_mc_list *im4;
1153         struct list_head *l;
1154         struct lcs_ipm_list *ipm;
1155         unsigned long flags;
1156         char buf[MAX_ADDR_LEN];
1157
1158         LCS_DBF_TEXT(4, trace, "remmclst");
1159         spin_lock_irqsave(&card->ipm_lock, flags);
1160         list_for_each(l, &card->ipm_list) {
1161                 ipm = list_entry(l, struct lcs_ipm_list, list);
1162                 for (im4 = rcu_dereference(in4_dev->mc_list);
1163                      im4 != NULL; im4 = rcu_dereference(im4->next_rcu)) {
1164                         lcs_get_mac_for_ipm(im4->multiaddr, buf, card->dev);
1165                         if ( (ipm->ipm.ip_addr == im4->multiaddr) &&
1166                              (memcmp(buf, &ipm->ipm.mac_addr,
1167                                      LCS_MAC_LENGTH) == 0) )
1168                                 break;
1169                 }
1170                 if (im4 == NULL)
1171                         ipm->ipm_state = LCS_IPM_STATE_DEL_REQUIRED;
1172         }
1173         spin_unlock_irqrestore(&card->ipm_lock, flags);
1174 }
1175
1176 static struct lcs_ipm_list *lcs_check_addr_entry(struct lcs_card *card,
1177                                                  struct ip_mc_list *im4,
1178                                                  char *buf)
1179 {
1180         struct lcs_ipm_list *tmp, *ipm = NULL;
1181         struct list_head *l;
1182         unsigned long flags;
1183
1184         LCS_DBF_TEXT(4, trace, "chkmcent");
1185         spin_lock_irqsave(&card->ipm_lock, flags);
1186         list_for_each(l, &card->ipm_list) {
1187                 tmp = list_entry(l, struct lcs_ipm_list, list);
1188                 if ( (tmp->ipm.ip_addr == im4->multiaddr) &&
1189                      (memcmp(buf, &tmp->ipm.mac_addr,
1190                              LCS_MAC_LENGTH) == 0) ) {
1191                         ipm = tmp;
1192                         break;
1193                 }
1194         }
1195         spin_unlock_irqrestore(&card->ipm_lock, flags);
1196         return ipm;
1197 }
1198
1199 static void lcs_set_mc_addresses(struct lcs_card *card,
1200                                  struct in_device *in4_dev)
1201 {
1202
1203         struct ip_mc_list *im4;
1204         struct lcs_ipm_list *ipm;
1205         char buf[MAX_ADDR_LEN];
1206         unsigned long flags;
1207
1208         LCS_DBF_TEXT(4, trace, "setmclst");
1209         for (im4 = rcu_dereference(in4_dev->mc_list); im4 != NULL;
1210              im4 = rcu_dereference(im4->next_rcu)) {
1211                 lcs_get_mac_for_ipm(im4->multiaddr, buf, card->dev);
1212                 ipm = lcs_check_addr_entry(card, im4, buf);
1213                 if (ipm != NULL)
1214                         continue;       /* Address already in list. */
1215                 ipm = kzalloc(sizeof(struct lcs_ipm_list), GFP_ATOMIC);
1216                 if (ipm == NULL) {
1217                         pr_info("Not enough memory to add"
1218                                 " new multicast entry!\n");
1219                         break;
1220                 }
1221                 memcpy(&ipm->ipm.mac_addr, buf, LCS_MAC_LENGTH);
1222                 ipm->ipm.ip_addr = im4->multiaddr;
1223                 ipm->ipm_state = LCS_IPM_STATE_SET_REQUIRED;
1224                 spin_lock_irqsave(&card->ipm_lock, flags);
1225                 LCS_DBF_HEX(2,trace,&ipm->ipm.ip_addr,4);
1226                 list_add(&ipm->list, &card->ipm_list);
1227                 spin_unlock_irqrestore(&card->ipm_lock, flags);
1228         }
1229 }
1230
1231 static int
1232 lcs_register_mc_addresses(void *data)
1233 {
1234         struct lcs_card *card;
1235         struct in_device *in4_dev;
1236
1237         card = (struct lcs_card *) data;
1238
1239         if (!lcs_do_run_thread(card, LCS_SET_MC_THREAD))
1240                 return 0;
1241         LCS_DBF_TEXT(4, trace, "regmulti");
1242
1243         in4_dev = in_dev_get(card->dev);
1244         if (in4_dev == NULL)
1245                 goto out;
1246         rcu_read_lock();
1247         lcs_remove_mc_addresses(card,in4_dev);
1248         lcs_set_mc_addresses(card, in4_dev);
1249         rcu_read_unlock();
1250         in_dev_put(in4_dev);
1251
1252         netif_carrier_off(card->dev);
1253         netif_tx_disable(card->dev);
1254         wait_event(card->write.wait_q,
1255                         (card->write.state != LCS_CH_STATE_RUNNING));
1256         lcs_fix_multicast_list(card);
1257         if (card->state == DEV_STATE_UP) {
1258                 netif_carrier_on(card->dev);
1259                 netif_wake_queue(card->dev);
1260         }
1261 out:
1262         lcs_clear_thread_running_bit(card, LCS_SET_MC_THREAD);
1263         return 0;
1264 }
1265 #endif /* CONFIG_IP_MULTICAST */
1266
1267 /**
1268  * function called by net device to
1269  * handle multicast address relevant things
1270  */
1271 static void
1272 lcs_set_multicast_list(struct net_device *dev)
1273 {
1274 #ifdef CONFIG_IP_MULTICAST
1275         struct lcs_card *card;
1276
1277         LCS_DBF_TEXT(4, trace, "setmulti");
1278         card = (struct lcs_card *) dev->ml_priv;
1279
1280         if (!lcs_set_thread_start_bit(card, LCS_SET_MC_THREAD))
1281                 schedule_work(&card->kernel_thread_starter);
1282 #endif /* CONFIG_IP_MULTICAST */
1283 }
1284
1285 static long
1286 lcs_check_irb_error(struct ccw_device *cdev, struct irb *irb)
1287 {
1288         if (!IS_ERR(irb))
1289                 return 0;
1290
1291         switch (PTR_ERR(irb)) {
1292         case -EIO:
1293                 dev_warn(&cdev->dev,
1294                         "An I/O-error occurred on the LCS device\n");
1295                 LCS_DBF_TEXT(2, trace, "ckirberr");
1296                 LCS_DBF_TEXT_(2, trace, "  rc%d", -EIO);
1297                 break;
1298         case -ETIMEDOUT:
1299                 dev_warn(&cdev->dev,
1300                         "A command timed out on the LCS device\n");
1301                 LCS_DBF_TEXT(2, trace, "ckirberr");
1302                 LCS_DBF_TEXT_(2, trace, "  rc%d", -ETIMEDOUT);
1303                 break;
1304         default:
1305                 dev_warn(&cdev->dev,
1306                         "An error occurred on the LCS device, rc=%ld\n",
1307                         PTR_ERR(irb));
1308                 LCS_DBF_TEXT(2, trace, "ckirberr");
1309                 LCS_DBF_TEXT(2, trace, "  rc???");
1310         }
1311         return PTR_ERR(irb);
1312 }
1313
1314 static int
1315 lcs_get_problem(struct ccw_device *cdev, struct irb *irb)
1316 {
1317         int dstat, cstat;
1318         char *sense;
1319
1320         sense = (char *) irb->ecw;
1321         cstat = irb->scsw.cmd.cstat;
1322         dstat = irb->scsw.cmd.dstat;
1323
1324         if (cstat & (SCHN_STAT_CHN_CTRL_CHK | SCHN_STAT_INTF_CTRL_CHK |
1325                      SCHN_STAT_CHN_DATA_CHK | SCHN_STAT_CHAIN_CHECK |
1326                      SCHN_STAT_PROT_CHECK   | SCHN_STAT_PROG_CHECK)) {
1327                 LCS_DBF_TEXT(2, trace, "CGENCHK");
1328                 return 1;
1329         }
1330         if (dstat & DEV_STAT_UNIT_CHECK) {
1331                 if (sense[LCS_SENSE_BYTE_1] &
1332                     LCS_SENSE_RESETTING_EVENT) {
1333                         LCS_DBF_TEXT(2, trace, "REVIND");
1334                         return 1;
1335                 }
1336                 if (sense[LCS_SENSE_BYTE_0] &
1337                     LCS_SENSE_CMD_REJECT) {
1338                         LCS_DBF_TEXT(2, trace, "CMDREJ");
1339                         return 0;
1340                 }
1341                 if ((!sense[LCS_SENSE_BYTE_0]) &&
1342                     (!sense[LCS_SENSE_BYTE_1]) &&
1343                     (!sense[LCS_SENSE_BYTE_2]) &&
1344                     (!sense[LCS_SENSE_BYTE_3])) {
1345                         LCS_DBF_TEXT(2, trace, "ZEROSEN");
1346                         return 0;
1347                 }
1348                 LCS_DBF_TEXT(2, trace, "DGENCHK");
1349                 return 1;
1350         }
1351         return 0;
1352 }
1353
1354 static void
1355 lcs_schedule_recovery(struct lcs_card *card)
1356 {
1357         LCS_DBF_TEXT(2, trace, "startrec");
1358         if (!lcs_set_thread_start_bit(card, LCS_RECOVERY_THREAD))
1359                 schedule_work(&card->kernel_thread_starter);
1360 }
1361
1362 /**
1363  * IRQ Handler for LCS channels
1364  */
1365 static void
1366 lcs_irq(struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
1367 {
1368         struct lcs_card *card;
1369         struct lcs_channel *channel;
1370         int rc, index;
1371         int cstat, dstat;
1372
1373         if (lcs_check_irb_error(cdev, irb))
1374                 return;
1375
1376         card = CARD_FROM_DEV(cdev);
1377         if (card->read.ccwdev == cdev)
1378                 channel = &card->read;
1379         else
1380                 channel = &card->write;
1381
1382         cstat = irb->scsw.cmd.cstat;
1383         dstat = irb->scsw.cmd.dstat;
1384         LCS_DBF_TEXT_(5, trace, "Rint%s", dev_name(&cdev->dev));
1385         LCS_DBF_TEXT_(5, trace, "%4x%4x", irb->scsw.cmd.cstat,
1386                       irb->scsw.cmd.dstat);
1387         LCS_DBF_TEXT_(5, trace, "%4x%4x", irb->scsw.cmd.fctl,
1388                       irb->scsw.cmd.actl);
1389
1390         /* Check for channel and device errors presented */
1391         rc = lcs_get_problem(cdev, irb);
1392         if (rc || (dstat & DEV_STAT_UNIT_EXCEP)) {
1393                 dev_warn(&cdev->dev,
1394                         "The LCS device stopped because of an error,"
1395                         " dstat=0x%X, cstat=0x%X \n",
1396                             dstat, cstat);
1397                 if (rc) {
1398                         channel->state = LCS_CH_STATE_ERROR;
1399                 }
1400         }
1401         if (channel->state == LCS_CH_STATE_ERROR) {
1402                 lcs_schedule_recovery(card);
1403                 wake_up(&card->wait_q);
1404                 return;
1405         }
1406         /* How far in the ccw chain have we processed? */
1407         if ((channel->state != LCS_CH_STATE_INIT) &&
1408             (irb->scsw.cmd.fctl & SCSW_FCTL_START_FUNC) &&
1409             (irb->scsw.cmd.cpa != 0)) {
1410                 index = (struct ccw1 *) __va((addr_t) irb->scsw.cmd.cpa)
1411                         - channel->ccws;
1412                 if ((irb->scsw.cmd.actl & SCSW_ACTL_SUSPENDED) ||
1413                     (irb->scsw.cmd.cstat & SCHN_STAT_PCI))
1414                         /* Bloody io subsystem tells us lies about cpa... */
1415                         index = (index - 1) & (LCS_NUM_BUFFS - 1);
1416                 while (channel->io_idx != index) {
1417                         __lcs_processed_buffer(channel,
1418                                                channel->iob + channel->io_idx);
1419                         channel->io_idx =
1420                                 (channel->io_idx + 1) & (LCS_NUM_BUFFS - 1);
1421                 }
1422         }
1423
1424         if ((irb->scsw.cmd.dstat & DEV_STAT_DEV_END) ||
1425             (irb->scsw.cmd.dstat & DEV_STAT_CHN_END) ||
1426             (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK))
1427                 /* Mark channel as stopped. */
1428                 channel->state = LCS_CH_STATE_STOPPED;
1429         else if (irb->scsw.cmd.actl & SCSW_ACTL_SUSPENDED)
1430                 /* CCW execution stopped on a suspend bit. */
1431                 channel->state = LCS_CH_STATE_SUSPENDED;
1432         if (irb->scsw.cmd.fctl & SCSW_FCTL_HALT_FUNC) {
1433                 if (irb->scsw.cmd.cc != 0) {
1434                         ccw_device_halt(channel->ccwdev, (addr_t) channel);
1435                         return;
1436                 }
1437                 /* The channel has been stopped by halt_IO. */
1438                 channel->state = LCS_CH_STATE_HALTED;
1439         }
1440         if (irb->scsw.cmd.fctl & SCSW_FCTL_CLEAR_FUNC)
1441                 channel->state = LCS_CH_STATE_CLEARED;
1442         /* Do the rest in the tasklet. */
1443         tasklet_schedule(&channel->irq_tasklet);
1444 }
1445
1446 /**
1447  * Tasklet for IRQ handler
1448  */
1449 static void
1450 lcs_tasklet(unsigned long data)
1451 {
1452         unsigned long flags;
1453         struct lcs_channel *channel;
1454         struct lcs_buffer *iob;
1455         int buf_idx;
1456
1457         channel = (struct lcs_channel *) data;
1458         LCS_DBF_TEXT_(5, trace, "tlet%s", dev_name(&channel->ccwdev->dev));
1459
1460         /* Check for processed buffers. */
1461         iob = channel->iob;
1462         buf_idx = channel->buf_idx;
1463         while (iob[buf_idx].state == LCS_BUF_STATE_PROCESSED) {
1464                 /* Do the callback thing. */
1465                 if (iob[buf_idx].callback != NULL)
1466                         iob[buf_idx].callback(channel, iob + buf_idx);
1467                 buf_idx = (buf_idx + 1) & (LCS_NUM_BUFFS - 1);
1468         }
1469         channel->buf_idx = buf_idx;
1470
1471         if (channel->state == LCS_CH_STATE_STOPPED)
1472                 lcs_start_channel(channel);
1473         spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
1474         if (channel->state == LCS_CH_STATE_SUSPENDED &&
1475             channel->iob[channel->io_idx].state == LCS_BUF_STATE_READY)
1476                 __lcs_resume_channel(channel);
1477         spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
1478
1479         /* Something happened on the channel. Wake up waiters. */
1480         wake_up(&channel->wait_q);
1481 }
1482
1483 /**
1484  * Finish current tx buffer and make it ready for transmit.
1485  */
1486 static void
1487 __lcs_emit_txbuffer(struct lcs_card *card)
1488 {
1489         LCS_DBF_TEXT(5, trace, "emittx");
1490         *(__u16 *)(card->tx_buffer->data + card->tx_buffer->count) = 0;
1491         card->tx_buffer->count += 2;
1492         lcs_ready_buffer(&card->write, card->tx_buffer);
1493         card->tx_buffer = NULL;
1494         card->tx_emitted++;
1495 }
1496
1497 /**
1498  * Callback for finished tx buffers.
1499  */
1500 static void
1501 lcs_txbuffer_cb(struct lcs_channel *channel, struct lcs_buffer *buffer)
1502 {
1503         struct lcs_card *card;
1504
1505         LCS_DBF_TEXT(5, trace, "txbuffcb");
1506         /* Put buffer back to pool. */
1507         lcs_release_buffer(channel, buffer);
1508         card = container_of(channel, struct lcs_card, write);
1509         if (netif_queue_stopped(card->dev) && netif_carrier_ok(card->dev))
1510                 netif_wake_queue(card->dev);
1511         spin_lock(&card->lock);
1512         card->tx_emitted--;
1513         if (card->tx_emitted <= 0 && card->tx_buffer != NULL)
1514                 /*
1515                  * Last running tx buffer has finished. Submit partially
1516                  * filled current buffer.
1517                  */
1518                 __lcs_emit_txbuffer(card);
1519         spin_unlock(&card->lock);
1520 }
1521
1522 /**
1523  * Packet transmit function called by network stack
1524  */
1525 static int
1526 __lcs_start_xmit(struct lcs_card *card, struct sk_buff *skb,
1527                  struct net_device *dev)
1528 {
1529         struct lcs_header *header;
1530         int rc = NETDEV_TX_OK;
1531
1532         LCS_DBF_TEXT(5, trace, "hardxmit");
1533         if (skb == NULL) {
1534                 card->stats.tx_dropped++;
1535                 card->stats.tx_errors++;
1536                 return NETDEV_TX_OK;
1537         }
1538         if (card->state != DEV_STATE_UP) {
1539                 dev_kfree_skb(skb);
1540                 card->stats.tx_dropped++;
1541                 card->stats.tx_errors++;
1542                 card->stats.tx_carrier_errors++;
1543                 return NETDEV_TX_OK;
1544         }
1545         if (skb->protocol == htons(ETH_P_IPV6)) {
1546                 dev_kfree_skb(skb);
1547                 return NETDEV_TX_OK;
1548         }
1549         netif_stop_queue(card->dev);
1550         spin_lock(&card->lock);
1551         if (card->tx_buffer != NULL &&
1552             card->tx_buffer->count + sizeof(struct lcs_header) +
1553             skb->len + sizeof(u16) > LCS_IOBUFFERSIZE)
1554                 /* skb too big for current tx buffer. */
1555                 __lcs_emit_txbuffer(card);
1556         if (card->tx_buffer == NULL) {
1557                 /* Get new tx buffer */
1558                 card->tx_buffer = lcs_get_buffer(&card->write);
1559                 if (card->tx_buffer == NULL) {
1560                         card->stats.tx_dropped++;
1561                         rc = NETDEV_TX_BUSY;
1562                         goto out;
1563                 }
1564                 card->tx_buffer->callback = lcs_txbuffer_cb;
1565                 card->tx_buffer->count = 0;
1566         }
1567         header = (struct lcs_header *)
1568                 (card->tx_buffer->data + card->tx_buffer->count);
1569         card->tx_buffer->count += skb->len + sizeof(struct lcs_header);
1570         header->offset = card->tx_buffer->count;
1571         header->type = card->lan_type;
1572         header->slot = card->portno;
1573         skb_copy_from_linear_data(skb, header + 1, skb->len);
1574         spin_unlock(&card->lock);
1575         card->stats.tx_bytes += skb->len;
1576         card->stats.tx_packets++;
1577         dev_kfree_skb(skb);
1578         netif_wake_queue(card->dev);
1579         spin_lock(&card->lock);
1580         if (card->tx_emitted <= 0 && card->tx_buffer != NULL)
1581                 /* If this is the first tx buffer emit it immediately. */
1582                 __lcs_emit_txbuffer(card);
1583 out:
1584         spin_unlock(&card->lock);
1585         return rc;
1586 }
1587
1588 static int
1589 lcs_start_xmit(struct sk_buff *skb, struct net_device *dev)
1590 {
1591         struct lcs_card *card;
1592         int rc;
1593
1594         LCS_DBF_TEXT(5, trace, "pktxmit");
1595         card = (struct lcs_card *) dev->ml_priv;
1596         rc = __lcs_start_xmit(card, skb, dev);
1597         return rc;
1598 }
1599
1600 /**
1601  * send startlan and lanstat command to make LCS device ready
1602  */
1603 static int
1604 lcs_startlan_auto(struct lcs_card *card)
1605 {
1606         int rc;
1607
1608         LCS_DBF_TEXT(2, trace, "strtauto");
1609 #ifdef CONFIG_ETHERNET
1610         card->lan_type = LCS_FRAME_TYPE_ENET;
1611         rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP);
1612         if (rc == 0)
1613                 return 0;
1614
1615 #endif
1616 #ifdef CONFIG_FDDI
1617         card->lan_type = LCS_FRAME_TYPE_FDDI;
1618         rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP);
1619         if (rc == 0)
1620                 return 0;
1621 #endif
1622         return -EIO;
1623 }
1624
1625 static int
1626 lcs_startlan(struct lcs_card *card)
1627 {
1628         int rc, i;
1629
1630         LCS_DBF_TEXT(2, trace, "startlan");
1631         rc = 0;
1632         if (card->portno != LCS_INVALID_PORT_NO) {
1633                 if (card->lan_type == LCS_FRAME_TYPE_AUTO)
1634                         rc = lcs_startlan_auto(card);
1635                 else
1636                         rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP);
1637         } else {
1638                 for (i = 0; i <= 16; i++) {
1639                         card->portno = i;
1640                         if (card->lan_type != LCS_FRAME_TYPE_AUTO)
1641                                 rc = lcs_send_startlan(card,
1642                                                        LCS_INITIATOR_TCPIP);
1643                         else
1644                                 /* autodetecting lan type */
1645                                 rc = lcs_startlan_auto(card);
1646                         if (rc == 0)
1647                                 break;
1648                 }
1649         }
1650         if (rc == 0)
1651                 return lcs_send_lanstat(card);
1652         return rc;
1653 }
1654
1655 /**
1656  * LCS detect function
1657  * setup channels and make them I/O ready
1658  */
1659 static int
1660 lcs_detect(struct lcs_card *card)
1661 {
1662         int rc = 0;
1663
1664         LCS_DBF_TEXT(2, setup, "lcsdetct");
1665         /* start/reset card */
1666         if (card->dev)
1667                 netif_stop_queue(card->dev);
1668         rc = lcs_stop_channels(card);
1669         if (rc == 0) {
1670                 rc = lcs_start_channels(card);
1671                 if (rc == 0) {
1672                         rc = lcs_send_startup(card, LCS_INITIATOR_TCPIP);
1673                         if (rc == 0)
1674                                 rc = lcs_startlan(card);
1675                 }
1676         }
1677         if (rc == 0) {
1678                 card->state = DEV_STATE_UP;
1679         } else {
1680                 card->state = DEV_STATE_DOWN;
1681                 card->write.state = LCS_CH_STATE_INIT;
1682                 card->read.state =  LCS_CH_STATE_INIT;
1683         }
1684         return rc;
1685 }
1686
1687 /**
1688  * LCS Stop card
1689  */
1690 static int
1691 lcs_stopcard(struct lcs_card *card)
1692 {
1693         int rc;
1694
1695         LCS_DBF_TEXT(3, setup, "stopcard");
1696
1697         if (card->read.state != LCS_CH_STATE_STOPPED &&
1698             card->write.state != LCS_CH_STATE_STOPPED &&
1699             card->read.state != LCS_CH_STATE_ERROR &&
1700             card->write.state != LCS_CH_STATE_ERROR &&
1701             card->state == DEV_STATE_UP) {
1702                 lcs_clear_multicast_list(card);
1703                 rc = lcs_send_stoplan(card,LCS_INITIATOR_TCPIP);
1704                 rc = lcs_send_shutdown(card);
1705         }
1706         rc = lcs_stop_channels(card);
1707         card->state = DEV_STATE_DOWN;
1708
1709         return rc;
1710 }
1711
1712 /**
1713  * Kernel Thread helper functions for LGW initiated commands
1714  */
1715 static void
1716 lcs_start_kernel_thread(struct work_struct *work)
1717 {
1718         struct lcs_card *card = container_of(work, struct lcs_card, kernel_thread_starter);
1719         LCS_DBF_TEXT(5, trace, "krnthrd");
1720         if (lcs_do_start_thread(card, LCS_RECOVERY_THREAD))
1721                 kthread_run(lcs_recovery, card, "lcs_recover");
1722 #ifdef CONFIG_IP_MULTICAST
1723         if (lcs_do_start_thread(card, LCS_SET_MC_THREAD))
1724                 kthread_run(lcs_register_mc_addresses, card, "regipm");
1725 #endif
1726 }
1727
1728 /**
1729  * Process control frames.
1730  */
1731 static void
1732 lcs_get_control(struct lcs_card *card, struct lcs_cmd *cmd)
1733 {
1734         LCS_DBF_TEXT(5, trace, "getctrl");
1735         if (cmd->initiator == LCS_INITIATOR_LGW) {
1736                 switch(cmd->cmd_code) {
1737                 case LCS_CMD_STARTUP:
1738                 case LCS_CMD_STARTLAN:
1739                         lcs_schedule_recovery(card);
1740                         break;
1741                 case LCS_CMD_STOPLAN:
1742                         pr_warn("Stoplan for %s initiated by LGW\n",
1743                                 card->dev->name);
1744                         if (card->dev)
1745                                 netif_carrier_off(card->dev);
1746                         break;
1747                 default:
1748                         LCS_DBF_TEXT(5, trace, "noLGWcmd");
1749                         break;
1750                 }
1751         } else
1752                 lcs_notify_lancmd_waiters(card, cmd);
1753 }
1754
1755 /**
1756  * Unpack network packet.
1757  */
1758 static void
1759 lcs_get_skb(struct lcs_card *card, char *skb_data, unsigned int skb_len)
1760 {
1761         struct sk_buff *skb;
1762
1763         LCS_DBF_TEXT(5, trace, "getskb");
1764         if (card->dev == NULL ||
1765             card->state != DEV_STATE_UP)
1766                 /* The card isn't up. Ignore the packet. */
1767                 return;
1768
1769         skb = dev_alloc_skb(skb_len);
1770         if (skb == NULL) {
1771                 dev_err(&card->dev->dev,
1772                         " Allocating a socket buffer to interface %s failed\n",
1773                           card->dev->name);
1774                 card->stats.rx_dropped++;
1775                 return;
1776         }
1777         skb_put_data(skb, skb_data, skb_len);
1778         skb->protocol = card->lan_type_trans(skb, card->dev);
1779         card->stats.rx_bytes += skb_len;
1780         card->stats.rx_packets++;
1781         if (skb->protocol == htons(ETH_P_802_2))
1782                 *((__u32 *)skb->cb) = ++card->pkt_seq;
1783         netif_rx(skb);
1784 }
1785
1786 /**
1787  * LCS main routine to get packets and lancmd replies from the buffers
1788  */
1789 static void
1790 lcs_get_frames_cb(struct lcs_channel *channel, struct lcs_buffer *buffer)
1791 {
1792         struct lcs_card *card;
1793         struct lcs_header *lcs_hdr;
1794         __u16 offset;
1795
1796         LCS_DBF_TEXT(5, trace, "lcsgtpkt");
1797         lcs_hdr = (struct lcs_header *) buffer->data;
1798         if (lcs_hdr->offset == LCS_ILLEGAL_OFFSET) {
1799                 LCS_DBF_TEXT(4, trace, "-eiogpkt");
1800                 return;
1801         }
1802         card = container_of(channel, struct lcs_card, read);
1803         offset = 0;
1804         while (lcs_hdr->offset != 0) {
1805                 if (lcs_hdr->offset <= 0 ||
1806                     lcs_hdr->offset > LCS_IOBUFFERSIZE ||
1807                     lcs_hdr->offset < offset) {
1808                         /* Offset invalid. */
1809                         card->stats.rx_length_errors++;
1810                         card->stats.rx_errors++;
1811                         return;
1812                 }
1813                 /* What kind of frame is it? */
1814                 if (lcs_hdr->type == LCS_FRAME_TYPE_CONTROL)
1815                         /* Control frame. */
1816                         lcs_get_control(card, (struct lcs_cmd *) lcs_hdr);
1817                 else if (lcs_hdr->type == LCS_FRAME_TYPE_ENET ||
1818                          lcs_hdr->type == LCS_FRAME_TYPE_TR ||
1819                          lcs_hdr->type == LCS_FRAME_TYPE_FDDI)
1820                         /* Normal network packet. */
1821                         lcs_get_skb(card, (char *)(lcs_hdr + 1),
1822                                     lcs_hdr->offset - offset -
1823                                     sizeof(struct lcs_header));
1824                 else
1825                         /* Unknown frame type. */
1826                         ; // FIXME: error message ?
1827                 /* Proceed to next frame. */
1828                 offset = lcs_hdr->offset;
1829                 lcs_hdr->offset = LCS_ILLEGAL_OFFSET;
1830                 lcs_hdr = (struct lcs_header *) (buffer->data + offset);
1831         }
1832         /* The buffer is now empty. Make it ready again. */
1833         lcs_ready_buffer(&card->read, buffer);
1834 }
1835
1836 /**
1837  * get network statistics for ifconfig and other user programs
1838  */
1839 static struct net_device_stats *
1840 lcs_getstats(struct net_device *dev)
1841 {
1842         struct lcs_card *card;
1843
1844         LCS_DBF_TEXT(4, trace, "netstats");
1845         card = (struct lcs_card *) dev->ml_priv;
1846         return &card->stats;
1847 }
1848
1849 /**
1850  * stop lcs device
1851  * This function will be called by user doing ifconfig xxx down
1852  */
1853 static int
1854 lcs_stop_device(struct net_device *dev)
1855 {
1856         struct lcs_card *card;
1857         int rc;
1858
1859         LCS_DBF_TEXT(2, trace, "stopdev");
1860         card   = (struct lcs_card *) dev->ml_priv;
1861         netif_carrier_off(dev);
1862         netif_tx_disable(dev);
1863         dev->flags &= ~IFF_UP;
1864         wait_event(card->write.wait_q,
1865                 (card->write.state != LCS_CH_STATE_RUNNING));
1866         rc = lcs_stopcard(card);
1867         if (rc)
1868                 dev_err(&card->dev->dev,
1869                         " Shutting down the LCS device failed\n");
1870         return rc;
1871 }
1872
1873 /**
1874  * start lcs device and make it runnable
1875  * This function will be called by user doing ifconfig xxx up
1876  */
1877 static int
1878 lcs_open_device(struct net_device *dev)
1879 {
1880         struct lcs_card *card;
1881         int rc;
1882
1883         LCS_DBF_TEXT(2, trace, "opendev");
1884         card = (struct lcs_card *) dev->ml_priv;
1885         /* initialize statistics */
1886         rc = lcs_detect(card);
1887         if (rc) {
1888                 pr_err("Error in opening device!\n");
1889
1890         } else {
1891                 dev->flags |= IFF_UP;
1892                 netif_carrier_on(dev);
1893                 netif_wake_queue(dev);
1894                 card->state = DEV_STATE_UP;
1895         }
1896         return rc;
1897 }
1898
1899 /**
1900  * show function for portno called by cat or similar things
1901  */
1902 static ssize_t
1903 lcs_portno_show (struct device *dev, struct device_attribute *attr, char *buf)
1904 {
1905         struct lcs_card *card;
1906
1907         card = dev_get_drvdata(dev);
1908
1909         if (!card)
1910                 return 0;
1911
1912         return sprintf(buf, "%d\n", card->portno);
1913 }
1914
1915 /**
1916  * store the value which is piped to file portno
1917  */
1918 static ssize_t
1919 lcs_portno_store (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1920 {
1921         struct lcs_card *card;
1922         int rc;
1923         s16 value;
1924
1925         card = dev_get_drvdata(dev);
1926
1927         if (!card)
1928                 return 0;
1929
1930         rc = kstrtos16(buf, 0, &value);
1931         if (rc)
1932                 return -EINVAL;
1933         /* TODO: sanity checks */
1934         card->portno = value;
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         memcpy(card->dev->dev_addr, card->mac, LCS_MAC_LENGTH);
2166 #ifdef CONFIG_IP_MULTICAST
2167         if (!lcs_check_multicast_support(card))
2168                 card->dev->netdev_ops = &lcs_mc_netdev_ops;
2169 #endif
2170 netdev_out:
2171         lcs_set_allowed_threads(card,0xffffffff);
2172         if (recover_state == DEV_STATE_RECOVER) {
2173                 lcs_set_multicast_list(card->dev);
2174                 card->dev->flags |= IFF_UP;
2175                 netif_carrier_on(card->dev);
2176                 netif_wake_queue(card->dev);
2177                 card->state = DEV_STATE_UP;
2178         } else {
2179                 lcs_stopcard(card);
2180         }
2181
2182         if (lcs_register_netdev(ccwgdev) != 0)
2183                 goto out;
2184
2185         /* Print out supported assists: IPv6 */
2186         pr_info("LCS device %s %s IPv6 support\n", card->dev->name,
2187                 (card->ip_assists_supported & LCS_IPASS_IPV6_SUPPORT) ?
2188                 "with" : "without");
2189         /* Print out supported assist: Multicast */
2190         pr_info("LCS device %s %s Multicast support\n", card->dev->name,
2191                 (card->ip_assists_supported & LCS_IPASS_MULTICAST_SUPPORT) ?
2192                 "with" : "without");
2193         return 0;
2194 out:
2195
2196         ccw_device_set_offline(card->write.ccwdev);
2197 out_werr:
2198         ccw_device_set_offline(card->read.ccwdev);
2199 out_err:
2200         return -ENODEV;
2201 }
2202
2203 /**
2204  * lcs_shutdown_device, called when setting the group device offline.
2205  */
2206 static int
2207 __lcs_shutdown_device(struct ccwgroup_device *ccwgdev, int recovery_mode)
2208 {
2209         struct lcs_card *card;
2210         enum lcs_dev_states recover_state;
2211         int ret = 0, ret2 = 0, ret3 = 0;
2212
2213         LCS_DBF_TEXT(3, setup, "shtdndev");
2214         card = dev_get_drvdata(&ccwgdev->dev);
2215         if (!card)
2216                 return -ENODEV;
2217         if (recovery_mode == 0) {
2218                 lcs_set_allowed_threads(card, 0);
2219                 if (lcs_wait_for_threads(card, LCS_SET_MC_THREAD))
2220                         return -ERESTARTSYS;
2221         }
2222         LCS_DBF_HEX(3, setup, &card, sizeof(void*));
2223         recover_state = card->state;
2224
2225         ret = lcs_stop_device(card->dev);
2226         ret2 = ccw_device_set_offline(card->read.ccwdev);
2227         ret3 = ccw_device_set_offline(card->write.ccwdev);
2228         if (!ret)
2229                 ret = (ret2) ? ret2 : ret3;
2230         if (ret)
2231                 LCS_DBF_TEXT_(3, setup, "1err:%d", ret);
2232         if (recover_state == DEV_STATE_UP) {
2233                 card->state = DEV_STATE_RECOVER;
2234         }
2235         return 0;
2236 }
2237
2238 static int
2239 lcs_shutdown_device(struct ccwgroup_device *ccwgdev)
2240 {
2241         return __lcs_shutdown_device(ccwgdev, 0);
2242 }
2243
2244 /**
2245  * drive lcs recovery after startup and startlan initiated by Lan Gateway
2246  */
2247 static int
2248 lcs_recovery(void *ptr)
2249 {
2250         struct lcs_card *card;
2251         struct ccwgroup_device *gdev;
2252         int rc;
2253
2254         card = (struct lcs_card *) ptr;
2255
2256         LCS_DBF_TEXT(4, trace, "recover1");
2257         if (!lcs_do_run_thread(card, LCS_RECOVERY_THREAD))
2258                 return 0;
2259         LCS_DBF_TEXT(4, trace, "recover2");
2260         gdev = card->gdev;
2261         dev_warn(&gdev->dev,
2262                 "A recovery process has been started for the LCS device\n");
2263         rc = __lcs_shutdown_device(gdev, 1);
2264         rc = lcs_new_device(gdev);
2265         if (!rc)
2266                 pr_info("Device %s successfully recovered!\n",
2267                         card->dev->name);
2268         else
2269                 pr_info("Device %s could not be recovered!\n",
2270                         card->dev->name);
2271         lcs_clear_thread_running_bit(card, LCS_RECOVERY_THREAD);
2272         return 0;
2273 }
2274
2275 /**
2276  * lcs_remove_device, free buffers and card
2277  */
2278 static void
2279 lcs_remove_device(struct ccwgroup_device *ccwgdev)
2280 {
2281         struct lcs_card *card;
2282
2283         card = dev_get_drvdata(&ccwgdev->dev);
2284         if (!card)
2285                 return;
2286
2287         LCS_DBF_TEXT(3, setup, "remdev");
2288         LCS_DBF_HEX(3, setup, &card, sizeof(void*));
2289         if (ccwgdev->state == CCWGROUP_ONLINE) {
2290                 lcs_shutdown_device(ccwgdev);
2291         }
2292         if (card->dev)
2293                 unregister_netdev(card->dev);
2294         lcs_cleanup_card(card);
2295         lcs_free_card(card);
2296         dev_set_drvdata(&ccwgdev->dev, NULL);
2297         put_device(&ccwgdev->dev);
2298 }
2299
2300 static int lcs_pm_suspend(struct lcs_card *card)
2301 {
2302         if (card->dev)
2303                 netif_device_detach(card->dev);
2304         lcs_set_allowed_threads(card, 0);
2305         lcs_wait_for_threads(card, 0xffffffff);
2306         if (card->state != DEV_STATE_DOWN)
2307                 __lcs_shutdown_device(card->gdev, 1);
2308         return 0;
2309 }
2310
2311 static int lcs_pm_resume(struct lcs_card *card)
2312 {
2313         int rc = 0;
2314
2315         if (card->state == DEV_STATE_RECOVER)
2316                 rc = lcs_new_device(card->gdev);
2317         if (card->dev)
2318                 netif_device_attach(card->dev);
2319         if (rc) {
2320                 dev_warn(&card->gdev->dev, "The lcs device driver "
2321                         "failed to recover the device\n");
2322         }
2323         return rc;
2324 }
2325
2326 static int lcs_prepare(struct ccwgroup_device *gdev)
2327 {
2328         return 0;
2329 }
2330
2331 static void lcs_complete(struct ccwgroup_device *gdev)
2332 {
2333         return;
2334 }
2335
2336 static int lcs_freeze(struct ccwgroup_device *gdev)
2337 {
2338         struct lcs_card *card = dev_get_drvdata(&gdev->dev);
2339         return lcs_pm_suspend(card);
2340 }
2341
2342 static int lcs_thaw(struct ccwgroup_device *gdev)
2343 {
2344         struct lcs_card *card = dev_get_drvdata(&gdev->dev);
2345         return lcs_pm_resume(card);
2346 }
2347
2348 static int lcs_restore(struct ccwgroup_device *gdev)
2349 {
2350         struct lcs_card *card = dev_get_drvdata(&gdev->dev);
2351         return lcs_pm_resume(card);
2352 }
2353
2354 static struct ccw_device_id lcs_ids[] = {
2355         {CCW_DEVICE(0x3088, 0x08), .driver_info = lcs_channel_type_parallel},
2356         {CCW_DEVICE(0x3088, 0x1f), .driver_info = lcs_channel_type_2216},
2357         {CCW_DEVICE(0x3088, 0x60), .driver_info = lcs_channel_type_osa2},
2358         {},
2359 };
2360 MODULE_DEVICE_TABLE(ccw, lcs_ids);
2361
2362 static struct ccw_driver lcs_ccw_driver = {
2363         .driver = {
2364                 .owner  = THIS_MODULE,
2365                 .name   = "lcs",
2366         },
2367         .ids    = lcs_ids,
2368         .probe  = ccwgroup_probe_ccwdev,
2369         .remove = ccwgroup_remove_ccwdev,
2370         .int_class = IRQIO_LCS,
2371 };
2372
2373 /**
2374  * LCS ccwgroup driver registration
2375  */
2376 static struct ccwgroup_driver lcs_group_driver = {
2377         .driver = {
2378                 .owner  = THIS_MODULE,
2379                 .name   = "lcs",
2380         },
2381         .ccw_driver  = &lcs_ccw_driver,
2382         .setup       = lcs_probe_device,
2383         .remove      = lcs_remove_device,
2384         .set_online  = lcs_new_device,
2385         .set_offline = lcs_shutdown_device,
2386         .prepare     = lcs_prepare,
2387         .complete    = lcs_complete,
2388         .freeze      = lcs_freeze,
2389         .thaw        = lcs_thaw,
2390         .restore     = lcs_restore,
2391 };
2392
2393 static ssize_t group_store(struct device_driver *ddrv, const char *buf,
2394                            size_t count)
2395 {
2396         int err;
2397         err = ccwgroup_create_dev(lcs_root_dev, &lcs_group_driver, 2, buf);
2398         return err ? err : count;
2399 }
2400 static DRIVER_ATTR_WO(group);
2401
2402 static struct attribute *lcs_drv_attrs[] = {
2403         &driver_attr_group.attr,
2404         NULL,
2405 };
2406 static struct attribute_group lcs_drv_attr_group = {
2407         .attrs = lcs_drv_attrs,
2408 };
2409 static const struct attribute_group *lcs_drv_attr_groups[] = {
2410         &lcs_drv_attr_group,
2411         NULL,
2412 };
2413
2414 /**
2415  *  LCS Module/Kernel initialization function
2416  */
2417 static int
2418 __init lcs_init_module(void)
2419 {
2420         int rc;
2421
2422         pr_info("Loading %s\n", version);
2423         rc = lcs_register_debug_facility();
2424         LCS_DBF_TEXT(0, setup, "lcsinit");
2425         if (rc)
2426                 goto out_err;
2427         lcs_root_dev = root_device_register("lcs");
2428         rc = PTR_ERR_OR_ZERO(lcs_root_dev);
2429         if (rc)
2430                 goto register_err;
2431         rc = ccw_driver_register(&lcs_ccw_driver);
2432         if (rc)
2433                 goto ccw_err;
2434         lcs_group_driver.driver.groups = lcs_drv_attr_groups;
2435         rc = ccwgroup_driver_register(&lcs_group_driver);
2436         if (rc)
2437                 goto ccwgroup_err;
2438         return 0;
2439
2440 ccwgroup_err:
2441         ccw_driver_unregister(&lcs_ccw_driver);
2442 ccw_err:
2443         root_device_unregister(lcs_root_dev);
2444 register_err:
2445         lcs_unregister_debug_facility();
2446 out_err:
2447         pr_err("Initializing the lcs device driver failed\n");
2448         return rc;
2449 }
2450
2451
2452 /**
2453  *  LCS module cleanup function
2454  */
2455 static void
2456 __exit lcs_cleanup_module(void)
2457 {
2458         pr_info("Terminating lcs module.\n");
2459         LCS_DBF_TEXT(0, trace, "cleanup");
2460         ccwgroup_driver_unregister(&lcs_group_driver);
2461         ccw_driver_unregister(&lcs_ccw_driver);
2462         root_device_unregister(lcs_root_dev);
2463         lcs_unregister_debug_facility();
2464 }
2465
2466 module_init(lcs_init_module);
2467 module_exit(lcs_cleanup_module);
2468
2469 MODULE_AUTHOR("Frank Pavlic <fpavlic@de.ibm.com>");
2470 MODULE_LICENSE("GPL");
2471