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