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