drivers/s390/net/lcs.c

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