drivers/s390/net/lcs.c

   1 /*
   2  *  linux/drivers/s390/net/lcs.c
   3  *
   4  *  Linux for S/390 Lan Channel Station Network Driver
   5  *
   6  *  Copyright (C)  1999-2001 IBM Deutschland Entwicklung GmbH,
   7  *                           IBM Corporation
   8  *    Author(s): Original Code written by
   9  *                        DJ Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
  10  *               Rewritten by
  11  *                        Frank Pavlic (pavlic@de.ibm.com) and
  12  *                        Martin Schwidefsky <schwidefsky@de.ibm.com>
  13  *
  14  *    $Revision: 1.81 $  $Date: 2004/05/14 13:54:33 $
  15  *
  16  * This program is free software; you can redistribute it and/or modify
  17  * it under the terms of the GNU General Public License as published by
  18  * the Free Software Foundation; either version 2, or (at your option)
  19  * any later version.
  20  *
  21  * This program is distributed in the hope that it will be useful,
  22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24  * GNU General Public License for more details.
  25  *
  26  * You should have received a copy of the GNU General Public License
  27  * along with this program; if not, write to the Free Software
  28  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  29  */
  30
  31 #include <linux/module.h>
  32 #include <linux/if.h>
  33 #include <linux/netdevice.h>
  34 #include <linux/etherdevice.h>
  35 #include <linux/trdevice.h>
  36 #include <linux/fddidevice.h>
  37 #include <linux/inetdevice.h>
  38 #include <linux/in.h>
  39 #include <linux/igmp.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 #include "cu3088.h"
  51
  52
  53 #if !defined(CONFIG_NET_ETHERNET) && \
  54     !defined(CONFIG_TR) && !defined(CONFIG_FDDI)
  55 #error Cannot compile lcs.c without some net devices switched on.
  56 #endif
  57
  58 /**
  59  * initialization string for output
  60  */
  61 #define VERSION_LCS_C  "$Revision: 1.81 $"
  62
  63 static char version[] __initdata = "LCS driver ("VERSION_LCS_C "/" VERSION_LCS_H ")";
  64 static char debug_buffer[255];
  65
  66 /**
  67  * Some prototypes.
  68  */
  69 static void lcs_tasklet(unsigned long);
  70 static void lcs_start_kernel_thread(struct lcs_card *card);
  71 static void lcs_get_frames_cb(struct lcs_channel *, struct lcs_buffer *);
  72
  73 /**
  74  * Debug Facility Stuff
  75  */
  76 static debug_info_t *lcs_dbf_setup;
  77 static debug_info_t *lcs_dbf_trace;
  78
  79 /**
  80  *  LCS Debug Facility functions
  81  */
  82 static void
  83 lcs_unregister_debug_facility(void)
  84 {
  85         if (lcs_dbf_setup)
  86                 debug_unregister(lcs_dbf_setup);
  87         if (lcs_dbf_trace)
  88                 debug_unregister(lcs_dbf_trace);
  89 }
  90
  91 static int
  92 lcs_register_debug_facility(void)
  93 {
  94         lcs_dbf_setup = debug_register("lcs_setup", 1, 1, 8);
  95         lcs_dbf_trace = debug_register("lcs_trace", 1, 2, 8);
  96         if (lcs_dbf_setup == NULL || lcs_dbf_trace == NULL) {
  97                 PRINT_ERR("Not enough memory for debug facility.\n");
  98                 lcs_unregister_debug_facility();
  99                 return -ENOMEM;
 100         }
 101         debug_register_view(lcs_dbf_setup, &debug_hex_ascii_view);
 102         debug_set_level(lcs_dbf_setup, 2);
 103         debug_register_view(lcs_dbf_trace, &debug_hex_ascii_view);
 104         debug_set_level(lcs_dbf_trace, 2);
 105         return 0;
 106 }
 107
 108 /**
 109  * Allocate io buffers.
 110  */
 111 static int
 112 lcs_alloc_channel(struct lcs_channel *channel)
 113 {
 114         int cnt;
 115
 116         LCS_DBF_TEXT(2, setup, "ichalloc");
 117         for (cnt = 0; cnt < LCS_NUM_BUFFS; cnt++) {
 118                 /* alloc memory fo iobuffer */
 119                 channel->iob[cnt].data = (void *)
 120                         kmalloc(LCS_IOBUFFERSIZE, GFP_DMA | GFP_KERNEL);
 121                 if (channel->iob[cnt].data == NULL)
 122                         break;
 123                 memset(channel->iob[cnt].data, 0, LCS_IOBUFFERSIZE);
 124                 channel->iob[cnt].state = BUF_STATE_EMPTY;
 125         }
 126         if (cnt < LCS_NUM_BUFFS) {
 127                 /* Not all io buffers could be allocated. */
 128                 LCS_DBF_TEXT(2, setup, "echalloc");
 129                 while (cnt-- > 0)
 130                         kfree(channel->iob[cnt].data);
 131                 return -ENOMEM;
 132         }
 133         return 0;
 134 }
 135
 136 /**
 137  * Free io buffers.
 138  */
 139 static void
 140 lcs_free_channel(struct lcs_channel *channel)
 141 {
 142         int cnt;
 143
 144         LCS_DBF_TEXT(2, setup, "ichfree");
 145         for (cnt = 0; cnt < LCS_NUM_BUFFS; cnt++) {
 146                 if (channel->iob[cnt].data != NULL)
 147                         kfree(channel->iob[cnt].data);
 148                 channel->iob[cnt].data = NULL;
 149         }
 150 }
 151
 152 /*
 153  * Cleanup channel.
 154  */
 155 static void
 156 lcs_cleanup_channel(struct lcs_channel *channel)
 157 {
 158         LCS_DBF_TEXT(3, setup, "cleanch");
 159         /* Kill write channel tasklets. */
 160         tasklet_kill(&channel->irq_tasklet);
 161         /* Free channel buffers. */
 162         lcs_free_channel(channel);
 163 }
 164
 165 /**
 166  * LCS free memory for card and channels.
 167  */
 168 static void
 169 lcs_free_card(struct lcs_card *card)
 170 {
 171         LCS_DBF_TEXT(2, setup, "remcard");
 172         LCS_DBF_HEX(2, setup, &card, sizeof(void*));
 173         kfree(card);
 174 }
 175
 176 /**
 177  * LCS alloc memory for card and channels
 178  */
 179 static struct lcs_card *
 180 lcs_alloc_card(void)
 181 {
 182         struct lcs_card *card;
 183         int rc;
 184
 185         LCS_DBF_TEXT(2, setup, "alloclcs");
 186
 187         card = kmalloc(sizeof(struct lcs_card), GFP_KERNEL | GFP_DMA);
 188         if (card == NULL)
 189                 return NULL;
 190         memset(card, 0, sizeof(struct lcs_card));
 191         card->lan_type = LCS_FRAME_TYPE_AUTO;
 192         card->lancmd_timeout = LCS_LANCMD_TIMEOUT_DEFAULT;
 193         /* Allocate io buffers for the read channel. */
 194         rc = lcs_alloc_channel(&card->read);
 195         if (rc){
 196                 LCS_DBF_TEXT(2, setup, "iccwerr");
 197                 lcs_free_card(card);
 198                 return NULL;
 199         }
 200         /* Allocate io buffers for the write channel. */
 201         rc = lcs_alloc_channel(&card->write);
 202         if (rc) {
 203                 LCS_DBF_TEXT(2, setup, "iccwerr");
 204                 lcs_cleanup_channel(&card->read);
 205                 lcs_free_card(card);
 206                 return NULL;
 207         }
 208
 209 #ifdef CONFIG_IP_MULTICAST
 210         INIT_LIST_HEAD(&card->ipm_list);
 211 #endif
 212         LCS_DBF_HEX(2, setup, &card, sizeof(void*));
 213         return card;
 214 }
 215
 216 /*
 217  * Setup read channel.
 218  */
 219 static void
 220 lcs_setup_read_ccws(struct lcs_card *card)
 221 {
 222         int cnt;
 223
 224         LCS_DBF_TEXT(2, setup, "ireadccw");
 225         /* Setup read ccws. */
 226         memset(card->read.ccws, 0, sizeof (struct ccw1) * (LCS_NUM_BUFFS + 1));
 227         for (cnt = 0; cnt < LCS_NUM_BUFFS; cnt++) {
 228                 card->read.ccws[cnt].cmd_code = LCS_CCW_READ;
 229                 card->read.ccws[cnt].count = LCS_IOBUFFERSIZE;
 230                 card->read.ccws[cnt].flags =
 231                         CCW_FLAG_CC | CCW_FLAG_SLI | CCW_FLAG_PCI;
 232                 /*
 233                  * Note: we have allocated the buffer with GFP_DMA, so
 234                  * we do not need to do set_normalized_cda.
 235                  */
 236                 card->read.ccws[cnt].cda =
 237                         (__u32) __pa(card->read.iob[cnt].data);
 238                 ((struct lcs_header *)
 239                  card->read.iob[cnt].data)->offset = LCS_ILLEGAL_OFFSET;
 240                 card->read.iob[cnt].callback = lcs_get_frames_cb;
 241                 card->read.iob[cnt].state = BUF_STATE_READY;
 242                 card->read.iob[cnt].count = LCS_IOBUFFERSIZE;
 243         }
 244         card->read.ccws[0].flags &= ~CCW_FLAG_PCI;
 245         card->read.ccws[LCS_NUM_BUFFS - 1].flags &= ~CCW_FLAG_PCI;
 246         card->read.ccws[LCS_NUM_BUFFS - 1].flags |= CCW_FLAG_SUSPEND;
 247         /* Last ccw is a tic (transfer in channel). */
 248         card->read.ccws[LCS_NUM_BUFFS].cmd_code = LCS_CCW_TRANSFER;
 249         card->read.ccws[LCS_NUM_BUFFS].cda =
 250                 (__u32) __pa(card->read.ccws);
 251         /* Setg initial state of the read channel. */
 252         card->read.state = CH_STATE_INIT;
 253
 254         card->read.io_idx = 0;
 255         card->read.buf_idx = 0;
 256 }
 257
 258 static void
 259 lcs_setup_read(struct lcs_card *card)
 260 {
 261         LCS_DBF_TEXT(3, setup, "initread");
 262
 263         lcs_setup_read_ccws(card);
 264         /* Initialize read channel tasklet. */
 265         card->read.irq_tasklet.data = (unsigned long) &card->read;
 266         card->read.irq_tasklet.func = lcs_tasklet;
 267         /* Initialize waitqueue. */
 268         init_waitqueue_head(&card->read.wait_q);
 269 }
 270
 271 /*
 272  * Setup write channel.
 273  */
 274 static void
 275 lcs_setup_write_ccws(struct lcs_card *card)
 276 {
 277         int cnt;
 278
 279         LCS_DBF_TEXT(3, setup, "iwritccw");
 280         /* Setup write ccws. */
 281         memset(card->write.ccws, 0, sizeof(struct ccw1) * LCS_NUM_BUFFS + 1);
 282         for (cnt = 0; cnt < LCS_NUM_BUFFS; cnt++) {
 283                 card->write.ccws[cnt].cmd_code = LCS_CCW_WRITE;
 284                 card->write.ccws[cnt].count = 0;
 285                 card->write.ccws[cnt].flags =
 286                         CCW_FLAG_SUSPEND | CCW_FLAG_CC | CCW_FLAG_SLI;
 287                 /*
 288                  * Note: we have allocated the buffer with GFP_DMA, so
 289                  * we do not need to do set_normalized_cda.
 290                  */
 291                 card->write.ccws[cnt].cda =
 292                         (__u32) __pa(card->write.iob[cnt].data);
 293         }
 294         /* Last ccw is a tic (transfer in channel). */
 295         card->write.ccws[LCS_NUM_BUFFS].cmd_code = LCS_CCW_TRANSFER;
 296         card->write.ccws[LCS_NUM_BUFFS].cda =
 297                 (__u32) __pa(card->write.ccws);
 298         /* Set initial state of the write channel. */
 299         card->read.state = CH_STATE_INIT;
 300
 301         card->write.io_idx = 0;
 302         card->write.buf_idx = 0;
 303 }
 304
 305 static void
 306 lcs_setup_write(struct lcs_card *card)
 307 {
 308         LCS_DBF_TEXT(3, setup, "initwrit");
 309
 310         lcs_setup_write_ccws(card);
 311         /* Initialize write channel tasklet. */
 312         card->write.irq_tasklet.data = (unsigned long) &card->write;
 313         card->write.irq_tasklet.func = lcs_tasklet;
 314         /* Initialize waitqueue. */
 315         init_waitqueue_head(&card->write.wait_q);
 316 }
 317
 318
 319
 320 /**
 321  * Initialize channels,card and state machines.
 322  */
 323 static void
 324 lcs_setup_card(struct lcs_card *card)
 325 {
 326         LCS_DBF_TEXT(2, setup, "initcard");
 327         LCS_DBF_HEX(2, setup, &card, sizeof(void*));
 328
 329         lcs_setup_read(card);
 330         lcs_setup_write(card);
 331         /* Set cards initial state. */
 332         card->state = DEV_STATE_DOWN;
 333         card->tx_buffer = NULL;
 334         card->tx_emitted = 0;
 335
 336         /* Initialize kernel thread task used for LGW commands. */
 337         INIT_WORK(&card->kernel_thread_starter,
 338                   (void *)lcs_start_kernel_thread,card);
 339         card->thread_mask = 0;
 340         spin_lock_init(&card->lock);
 341         spin_lock_init(&card->ipm_lock);
 342 #ifdef CONFIG_IP_MULTICAST
 343         INIT_LIST_HEAD(&card->ipm_list);
 344 #endif
 345         INIT_LIST_HEAD(&card->lancmd_waiters);
 346 }
 347
 348 /**
 349  * Cleanup channels,card and state machines.
 350  */
 351 static void
 352 lcs_cleanup_card(struct lcs_card *card)
 353 {
 354         struct list_head *l, *n;
 355         struct lcs_ipm_list *ipm_list;
 356
 357         LCS_DBF_TEXT(3, setup, "cleancrd");
 358         LCS_DBF_HEX(2,setup,&card,sizeof(void*));
 359 #ifdef  CONFIG_IP_MULTICAST
 360         /* Free multicast list. */
 361         list_for_each_safe(l, n, &card->ipm_list) {
 362                 ipm_list = list_entry(l, struct lcs_ipm_list, list);
 363                 list_del(&ipm_list->list);
 364                 kfree(ipm_list);
 365         }
 366 #endif
 367         if (card->dev != NULL)
 368                 free_netdev(card->dev);
 369         /* Cleanup channels. */
 370         lcs_cleanup_channel(&card->write);
 371         lcs_cleanup_channel(&card->read);
 372 }
 373
 374 /**
 375  * Start channel.
 376  */
 377 static int
 378 lcs_start_channel(struct lcs_channel *channel)
 379 {
 380         unsigned long flags;
 381         int rc;
 382
 383         LCS_DBF_TEXT_(4,trace,"ssch%s", channel->ccwdev->dev.bus_id);
 384         spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
 385         rc = ccw_device_start(channel->ccwdev,
 386                               channel->ccws + channel->io_idx, 0, 0,
 387                               DOIO_DENY_PREFETCH | DOIO_ALLOW_SUSPEND);
 388         if (rc == 0)
 389                 channel->state = CH_STATE_RUNNING;
 390         spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
 391         if (rc) {
 392                 LCS_DBF_TEXT_(4,trace,"essh%s", channel->ccwdev->dev.bus_id);
 393                 PRINT_ERR("Error in starting channel, rc=%d!\n", rc);
 394         }
 395         return rc;
 396 }
 397
 398 static int
 399 lcs_clear_channel(struct lcs_channel *channel)
 400 {
 401         unsigned long flags;
 402         int rc;
 403
 404         LCS_DBF_TEXT(4,trace,"clearch");
 405         LCS_DBF_TEXT_(4,trace,"%s", channel->ccwdev->dev.bus_id);
 406         spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
 407         rc = ccw_device_clear(channel->ccwdev, (addr_t) channel);
 408         spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
 409         if (rc) {
 410                 LCS_DBF_TEXT_(4,trace,"ecsc%s", channel->ccwdev->dev.bus_id);
 411                 return rc;
 412         }
 413         wait_event(channel->wait_q, (channel->state == CH_STATE_CLEARED));
 414         channel->state = CH_STATE_STOPPED;
 415         return rc;
 416 }
 417
 418
 419 /**
 420  * Stop channel.
 421  */
 422 static int
 423 lcs_stop_channel(struct lcs_channel *channel)
 424 {
 425         unsigned long flags;
 426         int rc;
 427
 428         if (channel->state == CH_STATE_STOPPED)
 429                 return 0;
 430         LCS_DBF_TEXT(4,trace,"haltsch");
 431         LCS_DBF_TEXT_(4,trace,"%s", channel->ccwdev->dev.bus_id);
 432         spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
 433         rc = ccw_device_halt(channel->ccwdev, (addr_t) channel);
 434         spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
 435         if (rc) {
 436                 LCS_DBF_TEXT_(4,trace,"ehsc%s", channel->ccwdev->dev.bus_id);
 437                 return rc;
 438         }
 439         /* Asynchronous halt initialted. Wait for its completion. */
 440         wait_event(channel->wait_q, (channel->state == CH_STATE_HALTED));
 441         lcs_clear_channel(channel);
 442         return 0;
 443 }
 444
 445 /**
 446  * start read and write channel
 447  */
 448 static int
 449 lcs_start_channels(struct lcs_card *card)
 450 {
 451         int rc;
 452
 453         LCS_DBF_TEXT(2, trace, "chstart");
 454         /* start read channel */
 455         rc = lcs_start_channel(&card->read);
 456         if (rc)
 457                 return rc;
 458         /* start write channel */
 459         rc = lcs_start_channel(&card->write);
 460         if (rc)
 461                 lcs_stop_channel(&card->read);
 462         return rc;
 463 }
 464
 465 /**
 466  * stop read and write channel
 467  */
 468 static int
 469 lcs_stop_channels(struct lcs_card *card)
 470 {
 471         LCS_DBF_TEXT(2, trace, "chhalt");
 472         lcs_stop_channel(&card->read);
 473         lcs_stop_channel(&card->write);
 474         return 0;
 475 }
 476
 477 /**
 478  * Get empty buffer.
 479  */
 480 static struct lcs_buffer *
 481 __lcs_get_buffer(struct lcs_channel *channel)
 482 {
 483         int index;
 484
 485         LCS_DBF_TEXT(5, trace, "_getbuff");
 486         index = channel->io_idx;
 487         do {
 488                 if (channel->iob[index].state == BUF_STATE_EMPTY) {
 489                         channel->iob[index].state = BUF_STATE_LOCKED;
 490                         return channel->iob + index;
 491                 }
 492                 index = (index + 1) & (LCS_NUM_BUFFS - 1);
 493         } while (index != channel->io_idx);
 494         return NULL;
 495 }
 496
 497 static struct lcs_buffer *
 498 lcs_get_buffer(struct lcs_channel *channel)
 499 {
 500         struct lcs_buffer *buffer;
 501         unsigned long flags;
 502
 503         LCS_DBF_TEXT(5, trace, "getbuff");
 504         spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
 505         buffer = __lcs_get_buffer(channel);
 506         spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
 507         return buffer;
 508 }
 509
 510 /**
 511  * Resume channel program if the channel is suspended.
 512  */
 513 static int
 514 __lcs_resume_channel(struct lcs_channel *channel)
 515 {
 516         int rc;
 517
 518         if (channel->state != CH_STATE_SUSPENDED)
 519                 return 0;
 520         if (channel->ccws[channel->io_idx].flags & CCW_FLAG_SUSPEND)
 521                 return 0;
 522         LCS_DBF_TEXT_(5, trace, "rsch%s", channel->ccwdev->dev.bus_id);
 523         rc = ccw_device_resume(channel->ccwdev);
 524         if (rc) {
 525                 LCS_DBF_TEXT_(4, trace, "ersc%s", channel->ccwdev->dev.bus_id);
 526                 PRINT_ERR("Error in lcs_resume_channel: rc=%d\n",rc);
 527         } else
 528                 channel->state = CH_STATE_RUNNING;
 529         return rc;
 530
 531 }
 532
 533 /**
 534  * Make a buffer ready for processing.
 535  */
 536 static inline void
 537 __lcs_ready_buffer_bits(struct lcs_channel *channel, int index)
 538 {
 539         int prev, next;
 540
 541         LCS_DBF_TEXT(5, trace, "rdybits");
 542         prev = (index - 1) & (LCS_NUM_BUFFS - 1);
 543         next = (index + 1) & (LCS_NUM_BUFFS - 1);
 544         /* Check if we may clear the suspend bit of this buffer. */
 545         if (channel->ccws[next].flags & CCW_FLAG_SUSPEND) {
 546                 /* Check if we have to set the PCI bit. */
 547                 if (!(channel->ccws[prev].flags & CCW_FLAG_SUSPEND))
 548                         /* Suspend bit of the previous buffer is not set. */
 549                         channel->ccws[index].flags |= CCW_FLAG_PCI;
 550                 /* Suspend bit of the next buffer is set. */
 551                 channel->ccws[index].flags &= ~CCW_FLAG_SUSPEND;
 552         }
 553 }
 554
 555 static int
 556 lcs_ready_buffer(struct lcs_channel *channel, struct lcs_buffer *buffer)
 557 {
 558         unsigned long flags;
 559         int index, rc;
 560
 561         LCS_DBF_TEXT(5, trace, "rdybuff");
 562         if (buffer->state != BUF_STATE_LOCKED &&
 563             buffer->state != BUF_STATE_PROCESSED)
 564                 BUG();
 565         spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
 566         buffer->state = BUF_STATE_READY;
 567         index = buffer - channel->iob;
 568         /* Set length. */
 569         channel->ccws[index].count = buffer->count;
 570         /* Check relevant PCI/suspend bits. */
 571         __lcs_ready_buffer_bits(channel, index);
 572         rc = __lcs_resume_channel(channel);
 573         spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
 574         return rc;
 575 }
 576
 577 /**
 578  * Mark the buffer as processed. Take care of the suspend bit
 579  * of the previous buffer. This function is called from
 580  * interrupt context, so the lock must not be taken.
 581  */
 582 static int
 583 __lcs_processed_buffer(struct lcs_channel *channel, struct lcs_buffer *buffer)
 584 {
 585         int index, prev, next;
 586
 587         LCS_DBF_TEXT(5, trace, "prcsbuff");
 588         if (buffer->state != BUF_STATE_READY)
 589                 BUG();
 590         buffer->state = BUF_STATE_PROCESSED;
 591         index = buffer - channel->iob;
 592         prev = (index - 1) & (LCS_NUM_BUFFS - 1);
 593         next = (index + 1) & (LCS_NUM_BUFFS - 1);
 594         /* Set the suspend bit and clear the PCI bit of this buffer. */
 595         channel->ccws[index].flags |= CCW_FLAG_SUSPEND;
 596         channel->ccws[index].flags &= ~CCW_FLAG_PCI;
 597         /* Check the suspend bit of the previous buffer. */
 598         if (channel->iob[prev].state == BUF_STATE_READY) {
 599                 /*
 600                  * Previous buffer is in state ready. It might have
 601                  * happened in lcs_ready_buffer that the suspend bit
 602                  * has not been cleared to avoid an endless loop.
 603                  * Do it now.
 604                  */
 605                 __lcs_ready_buffer_bits(channel, prev);
 606         }
 607         /* Clear PCI bit of next buffer. */
 608         channel->ccws[next].flags &= ~CCW_FLAG_PCI;
 609         return __lcs_resume_channel(channel);
 610 }
 611
 612 /**
 613  * Put a processed buffer back to state empty.
 614  */
 615 static void
 616 lcs_release_buffer(struct lcs_channel *channel, struct lcs_buffer *buffer)
 617 {
 618         unsigned long flags;
 619
 620         LCS_DBF_TEXT(5, trace, "relbuff");
 621         if (buffer->state != BUF_STATE_LOCKED &&
 622             buffer->state != BUF_STATE_PROCESSED)
 623                 BUG();
 624         spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
 625         buffer->state = BUF_STATE_EMPTY;
 626         spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
 627 }
 628
 629 /**
 630  * Get buffer for a lan command.
 631  */
 632 static struct lcs_buffer *
 633 lcs_get_lancmd(struct lcs_card *card, int count)
 634 {
 635         struct lcs_buffer *buffer;
 636         struct lcs_cmd *cmd;
 637
 638         LCS_DBF_TEXT(4, trace, "getlncmd");
 639         /* Get buffer and wait if none is available. */
 640         wait_event(card->write.wait_q,
 641                    ((buffer = lcs_get_buffer(&card->write)) != NULL));
 642         count += sizeof(struct lcs_header);
 643         *(__u16 *)(buffer->data + count) = 0;
 644         buffer->count = count + sizeof(__u16);
 645         buffer->callback = lcs_release_buffer;
 646         cmd = (struct lcs_cmd *) buffer->data;
 647         cmd->offset = count;
 648         cmd->type = LCS_FRAME_TYPE_CONTROL;
 649         cmd->slot = 0;
 650         return buffer;
 651 }
 652
 653 /**
 654  * Notifier function for lancmd replies. Called from read irq.
 655  */
 656 static void
 657 lcs_notify_lancmd_waiters(struct lcs_card *card, struct lcs_cmd *cmd)
 658 {
 659         struct list_head *l, *n;
 660         struct lcs_reply *reply;
 661
 662         LCS_DBF_TEXT(4, trace, "notiwait");
 663         spin_lock(&card->lock);
 664         list_for_each_safe(l, n, &card->lancmd_waiters) {
 665                 reply = list_entry(l, struct lcs_reply, list);
 666                 if (reply->sequence_no == cmd->sequence_no) {
 667                         list_del(&reply->list);
 668                         if (reply->callback != NULL)
 669                                 reply->callback(card, cmd);
 670                         reply->received = 1;
 671                         reply->rc = cmd->return_code;
 672                         wake_up(&reply->wait_q);
 673                         break;
 674                 }
 675         }
 676         spin_unlock(&card->lock);
 677 }
 678
 679 /**
 680  * Emit buffer of a lan comand.
 681  */
 682 void
 683 lcs_lancmd_timeout(unsigned long data)
 684 {
 685         struct lcs_reply *reply;
 686
 687         LCS_DBF_TEXT(4, trace, "timeout");
 688         reply = (struct lcs_reply *) data;
 689         list_del(&reply->list);
 690         reply->received = 1;
 691         reply->rc = -ETIME;
 692         wake_up(&reply->wait_q);
 693 }
 694
 695 static int
 696 lcs_send_lancmd(struct lcs_card *card, struct lcs_buffer *buffer,
 697                 void (*reply_callback)(struct lcs_card *, struct lcs_cmd *))
 698 {
 699         struct lcs_reply reply;
 700         struct lcs_cmd *cmd;
 701         struct timer_list timer;
 702         int rc;
 703
 704         LCS_DBF_TEXT(4, trace, "sendcmd");
 705         cmd = (struct lcs_cmd *) buffer->data;
 706         cmd->sequence_no = ++card->sequence_no;
 707         cmd->return_code = 0;
 708         reply.sequence_no = cmd->sequence_no;
 709         reply.callback = reply_callback;
 710         reply.received = 0;
 711         reply.rc = 0;
 712         init_waitqueue_head(&reply.wait_q);
 713         spin_lock(&card->lock);
 714         list_add_tail(&reply.list, &card->lancmd_waiters);
 715         spin_unlock(&card->lock);
 716         buffer->callback = lcs_release_buffer;
 717         rc = lcs_ready_buffer(&card->write, buffer);
 718         if (rc)
 719                 return rc;
 720         init_timer(&timer);
 721         timer.function = lcs_lancmd_timeout;
 722         timer.data = (unsigned long) &reply;
 723         timer.expires = jiffies + HZ*card->lancmd_timeout;
 724         add_timer(&timer);
 725         wait_event(reply.wait_q, reply.received);
 726         del_timer(&timer);
 727         LCS_DBF_TEXT_(4, trace, "rc:%d",reply.rc);
 728         return reply.rc ? -EIO : 0;
 729 }
 730
 731 /**
 732  * LCS startup command
 733  */
 734 static int
 735 lcs_send_startup(struct lcs_card *card, __u8 initiator)
 736 {
 737         struct lcs_buffer *buffer;
 738         struct lcs_cmd *cmd;
 739
 740         LCS_DBF_TEXT(2, trace, "startup");
 741         buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
 742         cmd = (struct lcs_cmd *) buffer->data;
 743         cmd->cmd_code = LCS_CMD_STARTUP;
 744         cmd->initiator = initiator;
 745         cmd->cmd.lcs_startup.buff_size = LCS_IOBUFFERSIZE;
 746         return lcs_send_lancmd(card, buffer, NULL);
 747 }
 748
 749 /**
 750  * LCS shutdown command
 751  */
 752 static int
 753 lcs_send_shutdown(struct lcs_card *card)
 754 {
 755         struct lcs_buffer *buffer;
 756         struct lcs_cmd *cmd;
 757
 758         LCS_DBF_TEXT(2, trace, "shutdown");
 759         buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
 760         cmd = (struct lcs_cmd *) buffer->data;
 761         cmd->cmd_code = LCS_CMD_SHUTDOWN;
 762         cmd->initiator = LCS_INITIATOR_TCPIP;
 763         return lcs_send_lancmd(card, buffer, NULL);
 764 }
 765
 766 /**
 767  * LCS lanstat command
 768  */
 769 static void
 770 __lcs_lanstat_cb(struct lcs_card *card, struct lcs_cmd *cmd)
 771 {
 772         LCS_DBF_TEXT(2, trace, "statcb");
 773         memcpy(card->mac, cmd->cmd.lcs_lanstat_cmd.mac_addr, LCS_MAC_LENGTH);
 774 }
 775
 776 static int
 777 lcs_send_lanstat(struct lcs_card *card)
 778 {
 779         struct lcs_buffer *buffer;
 780         struct lcs_cmd *cmd;
 781
 782         LCS_DBF_TEXT(2,trace, "cmdstat");
 783         buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
 784         cmd = (struct lcs_cmd *) buffer->data;
 785         /* Setup lanstat command. */
 786         cmd->cmd_code = LCS_CMD_LANSTAT;
 787         cmd->initiator = LCS_INITIATOR_TCPIP;
 788         cmd->cmd.lcs_std_cmd.lan_type = card->lan_type;
 789         cmd->cmd.lcs_std_cmd.portno = card->portno;
 790         return lcs_send_lancmd(card, buffer, __lcs_lanstat_cb);
 791 }
 792
 793 /**
 794  * send stoplan command
 795  */
 796 static int
 797 lcs_send_stoplan(struct lcs_card *card, __u8 initiator)
 798 {
 799         struct lcs_buffer *buffer;
 800         struct lcs_cmd *cmd;
 801
 802         LCS_DBF_TEXT(2, trace, "cmdstpln");
 803         buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
 804         cmd = (struct lcs_cmd *) buffer->data;
 805         cmd->cmd_code = LCS_CMD_STOPLAN;
 806         cmd->initiator = initiator;
 807         cmd->cmd.lcs_std_cmd.lan_type = card->lan_type;
 808         cmd->cmd.lcs_std_cmd.portno = card->portno;
 809         return lcs_send_lancmd(card, buffer, NULL);
 810 }
 811
 812 /**
 813  * send startlan command
 814  */
 815 static void
 816 __lcs_send_startlan_cb(struct lcs_card *card, struct lcs_cmd *cmd)
 817 {
 818         LCS_DBF_TEXT(2, trace, "srtlancb");
 819         card->lan_type = cmd->cmd.lcs_std_cmd.lan_type;
 820         card->portno = cmd->cmd.lcs_std_cmd.portno;
 821 }
 822
 823 static int
 824 lcs_send_startlan(struct lcs_card *card, __u8 initiator)
 825 {
 826         struct lcs_buffer *buffer;
 827         struct lcs_cmd *cmd;
 828
 829         LCS_DBF_TEXT(2, trace, "cmdstaln");
 830         buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
 831         cmd = (struct lcs_cmd *) buffer->data;
 832         cmd->cmd_code = LCS_CMD_STARTLAN;
 833         cmd->initiator = initiator;
 834         cmd->cmd.lcs_std_cmd.lan_type = card->lan_type;
 835         cmd->cmd.lcs_std_cmd.portno = card->portno;
 836         return lcs_send_lancmd(card, buffer, __lcs_send_startlan_cb);
 837 }
 838
 839 #ifdef CONFIG_IP_MULTICAST
 840 /**
 841  * send setipm command (Multicast)
 842  */
 843 static int
 844 lcs_send_setipm(struct lcs_card *card,struct lcs_ipm_list *ipm_list)
 845 {
 846         struct lcs_buffer *buffer;
 847         struct lcs_cmd *cmd;
 848
 849         LCS_DBF_TEXT(2, trace, "cmdsetim");
 850         buffer = lcs_get_lancmd(card, LCS_MULTICAST_CMD_SIZE);
 851         cmd = (struct lcs_cmd *) buffer->data;
 852         cmd->cmd_code = LCS_CMD_SETIPM;
 853         cmd->initiator = LCS_INITIATOR_TCPIP;
 854         cmd->cmd.lcs_qipassist.lan_type = card->lan_type;
 855         cmd->cmd.lcs_qipassist.portno = card->portno;
 856         cmd->cmd.lcs_qipassist.version = 4;
 857         cmd->cmd.lcs_qipassist.num_ip_pairs = 1;
 858         memcpy(cmd->cmd.lcs_qipassist.lcs_ipass_ctlmsg.ip_mac_pair,
 859                &ipm_list->ipm, sizeof (struct lcs_ip_mac_pair));
 860         LCS_DBF_TEXT_(2, trace, "%x",ipm_list->ipm.ip_addr);
 861         return lcs_send_lancmd(card, buffer, NULL);
 862 }
 863
 864 /**
 865  * send delipm command (Multicast)
 866  */
 867 static int
 868 lcs_send_delipm(struct lcs_card *card,struct lcs_ipm_list *ipm_list)
 869 {
 870         struct lcs_buffer *buffer;
 871         struct lcs_cmd *cmd;
 872
 873         LCS_DBF_TEXT(2, trace, "cmddelim");
 874         buffer = lcs_get_lancmd(card, LCS_MULTICAST_CMD_SIZE);
 875         cmd = (struct lcs_cmd *) buffer->data;
 876         cmd->cmd_code = LCS_CMD_DELIPM;
 877         cmd->initiator = LCS_INITIATOR_TCPIP;
 878         cmd->cmd.lcs_qipassist.lan_type = card->lan_type;
 879         cmd->cmd.lcs_qipassist.portno = card->portno;
 880         cmd->cmd.lcs_qipassist.version = 4;
 881         cmd->cmd.lcs_qipassist.num_ip_pairs = 1;
 882         memcpy(cmd->cmd.lcs_qipassist.lcs_ipass_ctlmsg.ip_mac_pair,
 883                &ipm_list->ipm, sizeof (struct lcs_ip_mac_pair));
 884         LCS_DBF_TEXT_(2, trace, "%x",ipm_list->ipm.ip_addr);
 885         return lcs_send_lancmd(card, buffer, NULL);
 886 }
 887
 888 /**
 889  * check if multicast is supported by LCS
 890  */
 891 static void
 892 __lcs_check_multicast_cb(struct lcs_card *card, struct lcs_cmd *cmd)
 893 {
 894         LCS_DBF_TEXT(2, trace, "chkmccb");
 895         card->ip_assists_supported =
 896                 cmd->cmd.lcs_qipassist.ip_assists_supported;
 897         card->ip_assists_enabled =
 898                 cmd->cmd.lcs_qipassist.ip_assists_enabled;
 899 }
 900
 901 static int
 902 lcs_check_multicast_support(struct lcs_card *card)
 903 {
 904         struct lcs_buffer *buffer;
 905         struct lcs_cmd *cmd;
 906         int rc;
 907
 908         LCS_DBF_TEXT(2, trace, "cmdqipa");
 909         /* Send query ipassist. */
 910         buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
 911         cmd = (struct lcs_cmd *) buffer->data;
 912         cmd->cmd_code = LCS_CMD_QIPASSIST;
 913         cmd->initiator = LCS_INITIATOR_TCPIP;
 914         cmd->cmd.lcs_qipassist.lan_type = card->lan_type;
 915         cmd->cmd.lcs_qipassist.portno = card->portno;
 916         cmd->cmd.lcs_qipassist.version = 4;
 917         cmd->cmd.lcs_qipassist.num_ip_pairs = 1;
 918         rc = lcs_send_lancmd(card, buffer, __lcs_check_multicast_cb);
 919         if (rc != 0) {
 920                 PRINT_ERR("Query IPAssist failed. Assuming unsupported!\n");
 921                 return -EOPNOTSUPP;
 922         }
 923         /* Print out supported assists: IPv6 */
 924         PRINT_INFO("LCS device %s %s IPv6 support\n", card->dev->name,
 925                    (card->ip_assists_supported & LCS_IPASS_IPV6_SUPPORT) ?
 926                    "with" : "without");
 927         /* Print out supported assist: Multicast */
 928         PRINT_INFO("LCS device %s %s Multicast support\n", card->dev->name,
 929                    (card->ip_assists_supported & LCS_IPASS_MULTICAST_SUPPORT) ?
 930                    "with" : "without");
 931         if (card->ip_assists_supported & LCS_IPASS_MULTICAST_SUPPORT)
 932                 return 0;
 933         return -EOPNOTSUPP;
 934 }
 935
 936 /**
 937  * set or del multicast address on LCS card
 938  */
 939 static void
 940 lcs_fix_multicast_list(struct lcs_card *card)
 941 {
 942         struct list_head *l, *n;
 943         struct lcs_ipm_list *ipm;
 944
 945         LCS_DBF_TEXT(4,trace, "fixipm");
 946         spin_lock(&card->ipm_lock);
 947         list_for_each_safe(l, n, &card->ipm_list) {
 948                 ipm = list_entry(l, struct lcs_ipm_list, list);
 949                 switch (ipm->ipm_state) {
 950                 case LCS_IPM_STATE_SET_REQUIRED:
 951                         if (lcs_send_setipm(card, ipm))
 952                                 PRINT_INFO("Adding multicast address failed."
 953                                            "Table possibly full!\n");
 954                         else
 955                                 ipm->ipm_state = LCS_IPM_STATE_ON_CARD;
 956                         break;
 957                 case LCS_IPM_STATE_DEL_REQUIRED:
 958                         lcs_send_delipm(card, ipm);
 959                         list_del(&ipm->list);
 960                         kfree(ipm);
 961                         break;
 962                 case LCS_IPM_STATE_ON_CARD:
 963                         break;
 964                 }
 965         }
 966         if (card->state == DEV_STATE_UP)
 967                 netif_wake_queue(card->dev);
 968         spin_unlock(&card->ipm_lock);
 969 }
 970
 971 /**
 972  * get mac address for the relevant Multicast address
 973  */
 974 static void
 975 lcs_get_mac_for_ipm(__u32 ipm, char *mac, struct net_device *dev)
 976 {
 977         LCS_DBF_TEXT(4,trace, "getmac");
 978         if (dev->type == ARPHRD_IEEE802_TR)
 979                 ip_tr_mc_map(ipm, mac);
 980         else
 981                 ip_eth_mc_map(ipm, mac);
 982 }
 983
 984 /**
 985  * function called by net device to handle multicast address relevant things
 986  */
 987 static int
 988 lcs_register_mc_addresses(void *data)
 989 {
 990         struct lcs_card *card;
 991         char buf[MAX_ADDR_LEN];
 992         struct list_head *l;
 993         struct ip_mc_list *im4;
 994         struct in_device *in4_dev;
 995         struct lcs_ipm_list *ipm, *tmp;
 996
 997         daemonize("regipm");
 998         LCS_DBF_TEXT(4, trace, "regmulti");
 999
1000         card = (struct lcs_card *) data;
1001         in4_dev = in_dev_get(card->dev);
1002         if (in4_dev == NULL)
1003                 return 0;
1004         read_lock(&in4_dev->lock);
1005         spin_lock(&card->ipm_lock);
1006         /* Check for multicast addresses to be removed. */
1007         list_for_each(l, &card->ipm_list) {
1008                 ipm = list_entry(l, struct lcs_ipm_list, list);
1009                 for (im4 = in4_dev->mc_list; im4 != NULL; im4 = im4->next) {
1010                         lcs_get_mac_for_ipm(im4->multiaddr, buf, card->dev);
1011                         if (memcmp(buf, &ipm->ipm.mac_addr,
1012                                    LCS_MAC_LENGTH) == 0 &&
1013                             ipm->ipm.ip_addr == im4->multiaddr)
1014                                 break;
1015                 }
1016                 if (im4 == NULL)
1017                         ipm->ipm_state = LCS_IPM_STATE_DEL_REQUIRED;
1018         }
1019         /* Check for multicast addresses to be added. */
1020         for (im4 = in4_dev->mc_list; im4; im4 = im4->next) {
1021                 lcs_get_mac_for_ipm(im4->multiaddr, buf, card->dev);
1022                 ipm = NULL;
1023                 list_for_each(l, &card->ipm_list) {
1024                         tmp = list_entry(l, struct lcs_ipm_list, list);
1025                         if (memcmp(buf, &tmp->ipm.mac_addr,
1026                                    LCS_MAC_LENGTH) == 0 &&
1027                             tmp->ipm.ip_addr == im4->multiaddr) {
1028                                 ipm = tmp;
1029                                 break;
1030                         }
1031                 }
1032                 if (ipm != NULL)
1033                         continue;       /* Address already in list. */
1034                 ipm = (struct lcs_ipm_list *)
1035                         kmalloc(sizeof(struct lcs_ipm_list), GFP_ATOMIC);
1036                 if (ipm == NULL) {
1037                         PRINT_INFO("Not enough memory to add "
1038                                    "new multicast entry!\n");
1039                         break;
1040                 }
1041                 memset(ipm, 0, sizeof(struct lcs_ipm_list));
1042                 memcpy(&ipm->ipm.mac_addr, buf, LCS_MAC_LENGTH);
1043                 ipm->ipm.ip_addr = im4->multiaddr;
1044                 ipm->ipm_state = LCS_IPM_STATE_SET_REQUIRED;
1045                 list_add(&ipm->list, &card->ipm_list);
1046         }
1047         spin_unlock(&card->ipm_lock);
1048         read_unlock(&in4_dev->lock);
1049         lcs_fix_multicast_list(card);
1050         in_dev_put(in4_dev);
1051         return 0;
1052 }
1053 /**
1054  * function called by net device to
1055  * handle multicast address relevant things
1056  */
1057 static void
1058 lcs_set_multicast_list(struct net_device *dev)
1059 {
1060         struct lcs_card *card;
1061
1062         LCS_DBF_TEXT(4, trace, "setmulti");
1063         card = (struct lcs_card *) dev->priv;
1064         set_bit(3, &card->thread_mask);
1065         schedule_work(&card->kernel_thread_starter);
1066 }
1067
1068 #endif /* CONFIG_IP_MULTICAST */
1069
1070 static long
1071 lcs_check_irb_error(struct ccw_device *cdev, struct irb *irb)
1072 {
1073         if (!IS_ERR(irb))
1074                 return 0;
1075
1076         switch (PTR_ERR(irb)) {
1077         case -EIO:
1078                 PRINT_WARN("i/o-error on device %s\n", cdev->dev.bus_id);
1079                 LCS_DBF_TEXT(2, trace, "ckirberr");
1080                 LCS_DBF_TEXT_(2, trace, "  rc%d", -EIO);
1081                 break;
1082         case -ETIMEDOUT:
1083                 PRINT_WARN("timeout on device %s\n", cdev->dev.bus_id);
1084                 LCS_DBF_TEXT(2, trace, "ckirberr");
1085                 LCS_DBF_TEXT_(2, trace, "  rc%d", -ETIMEDOUT);
1086                 break;
1087         default:
1088                 PRINT_WARN("unknown error %ld on device %s\n", PTR_ERR(irb),
1089                            cdev->dev.bus_id);
1090                 LCS_DBF_TEXT(2, trace, "ckirberr");
1091                 LCS_DBF_TEXT(2, trace, "  rc???");
1092         }
1093         return PTR_ERR(irb);
1094 }
1095
1096
1097 /**
1098  * IRQ Handler for LCS channels
1099  */
1100 static void
1101 lcs_irq(struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
1102 {
1103         struct lcs_card *card;
1104         struct lcs_channel *channel;
1105         int index;
1106
1107         if (lcs_check_irb_error(cdev, irb))
1108                 return;
1109
1110         card = CARD_FROM_DEV(cdev);
1111         if (card->read.ccwdev == cdev)
1112                 channel = &card->read;
1113         else
1114                 channel = &card->write;
1115
1116         LCS_DBF_TEXT_(5, trace, "Rint%s",cdev->dev.bus_id);
1117         LCS_DBF_TEXT_(5, trace, "%4x%4x",irb->scsw.cstat, irb->scsw.dstat);
1118
1119         /* How far in the ccw chain have we processed? */
1120         if ((channel->state != CH_STATE_INIT) &&
1121             (irb->scsw.fctl & SCSW_FCTL_START_FUNC)) {
1122                 index = (struct ccw1 *) __va((addr_t) irb->scsw.cpa)
1123                         - channel->ccws;
1124                 if ((irb->scsw.actl & SCSW_ACTL_SUSPENDED) ||
1125                     (irb->scsw.cstat | SCHN_STAT_PCI))
1126                         /* Bloody io subsystem tells us lies about cpa... */
1127                         index = (index - 1) & (LCS_NUM_BUFFS - 1);
1128                 while (channel->io_idx != index) {
1129                         __lcs_processed_buffer(channel,
1130                                                channel->iob + channel->io_idx);
1131                         channel->io_idx =
1132                                 (channel->io_idx + 1) & (LCS_NUM_BUFFS - 1);
1133                 }
1134         }
1135
1136         if ((irb->scsw.dstat & DEV_STAT_DEV_END) ||
1137             (irb->scsw.dstat & DEV_STAT_CHN_END) ||
1138             (irb->scsw.dstat & DEV_STAT_UNIT_CHECK))
1139                 /* Mark channel as stopped. */
1140                 channel->state = CH_STATE_STOPPED;
1141         else if (irb->scsw.actl & SCSW_ACTL_SUSPENDED)
1142                 /* CCW execution stopped on a suspend bit. */
1143                 channel->state = CH_STATE_SUSPENDED;
1144
1145         if (irb->scsw.fctl & SCSW_FCTL_HALT_FUNC) {
1146                 if (irb->scsw.cc != 0) {
1147                         ccw_device_halt(channel->ccwdev, (addr_t) channel);
1148                         return;
1149                 }
1150                 /* The channel has been stopped by halt_IO. */
1151                 channel->state = CH_STATE_HALTED;
1152         }
1153
1154         if (irb->scsw.fctl & SCSW_FCTL_CLEAR_FUNC) {
1155                 channel->state = CH_STATE_CLEARED;
1156         }
1157         /* Do the rest in the tasklet. */
1158         tasklet_schedule(&channel->irq_tasklet);
1159 }
1160
1161 /**
1162  * Tasklet for IRQ handler
1163  */
1164 static void
1165 lcs_tasklet(unsigned long data)
1166 {
1167         unsigned long flags;
1168         struct lcs_channel *channel;
1169         struct lcs_buffer *iob;
1170         int buf_idx;
1171         int rc;
1172
1173         channel = (struct lcs_channel *) data;
1174         LCS_DBF_TEXT_(5, trace, "tlet%s",channel->ccwdev->dev.bus_id);
1175
1176         /* Check for processed buffers. */
1177         iob = channel->iob;
1178         buf_idx = channel->buf_idx;
1179         while (iob[buf_idx].state == BUF_STATE_PROCESSED) {
1180                 /* Do the callback thing. */
1181                 if (iob[buf_idx].callback != NULL)
1182                         iob[buf_idx].callback(channel, iob + buf_idx);
1183                 buf_idx = (buf_idx + 1) & (LCS_NUM_BUFFS - 1);
1184         }
1185         channel->buf_idx = buf_idx;
1186
1187         if (channel->state == CH_STATE_STOPPED)
1188                 // FIXME: what if rc != 0 ??
1189                 rc = lcs_start_channel(channel);
1190         spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
1191         if (channel->state == CH_STATE_SUSPENDED &&
1192             channel->iob[channel->io_idx].state == BUF_STATE_READY) {
1193                 // FIXME: what if rc != 0 ??
1194                 rc = __lcs_resume_channel(channel);
1195         }
1196         spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
1197
1198         /* Something happened on the channel. Wake up waiters. */
1199         wake_up(&channel->wait_q);
1200 }
1201
1202 /**
1203  * Finish current tx buffer and make it ready for transmit.
1204  */
1205 static void
1206 __lcs_emit_txbuffer(struct lcs_card *card)
1207 {
1208         LCS_DBF_TEXT(5, trace, "emittx");
1209         *(__u16 *)(card->tx_buffer->data + card->tx_buffer->count) = 0;
1210         card->tx_buffer->count += 2;
1211         lcs_ready_buffer(&card->write, card->tx_buffer);
1212         card->tx_buffer = NULL;
1213         card->tx_emitted++;
1214 }
1215
1216 /**
1217  * Callback for finished tx buffers.
1218  */
1219 static void
1220 lcs_txbuffer_cb(struct lcs_channel *channel, struct lcs_buffer *buffer)
1221 {
1222         struct lcs_card *card;
1223
1224         LCS_DBF_TEXT(5, trace, "txbuffcb");
1225         /* Put buffer back to pool. */
1226         lcs_release_buffer(channel, buffer);
1227         card = (struct lcs_card *)
1228                 ((char *) channel - offsetof(struct lcs_card, write));
1229         spin_lock(&card->lock);
1230         card->tx_emitted--;
1231         if (card->tx_emitted <= 0 && card->tx_buffer != NULL)
1232                 /*
1233                  * Last running tx buffer has finished. Submit partially
1234                  * filled current buffer.
1235                  */
1236                 __lcs_emit_txbuffer(card);
1237         spin_unlock(&card->lock);
1238 }
1239
1240 /**
1241  * Packet transmit function called by network stack
1242  */
1243 static int
1244 __lcs_start_xmit(struct lcs_card *card, struct sk_buff *skb,
1245                  struct net_device *dev)
1246 {
1247         struct lcs_header *header;
1248
1249         LCS_DBF_TEXT(5, trace, "hardxmit");
1250         if (skb == NULL) {
1251                 card->stats.tx_dropped++;
1252                 card->stats.tx_errors++;
1253                 return -EIO;
1254         }
1255         if (card->state != DEV_STATE_UP) {
1256                 dev_kfree_skb(skb);
1257                 card->stats.tx_dropped++;
1258                 card->stats.tx_errors++;
1259                 card->stats.tx_carrier_errors++;
1260                 return 0;
1261         }
1262         if (netif_queue_stopped(dev) ) {
1263                 card->stats.tx_dropped++;
1264                 return -EBUSY;
1265         }
1266         if (card->tx_buffer != NULL &&
1267             card->tx_buffer->count + sizeof(struct lcs_header) +
1268             skb->len + sizeof(u16) > LCS_IOBUFFERSIZE)
1269                 /* skb too big for current tx buffer. */
1270                 __lcs_emit_txbuffer(card);
1271         if (card->tx_buffer == NULL) {
1272                 /* Get new tx buffer */
1273                 card->tx_buffer = lcs_get_buffer(&card->write);
1274                 if (card->tx_buffer == NULL) {
1275                         card->stats.tx_dropped++;
1276                         return -EBUSY;
1277                 }
1278                 card->tx_buffer->callback = lcs_txbuffer_cb;
1279                 card->tx_buffer->count = 0;
1280         }
1281         header = (struct lcs_header *)
1282                 (card->tx_buffer->data + card->tx_buffer->count);
1283         card->tx_buffer->count += skb->len + sizeof(struct lcs_header);
1284         header->offset = card->tx_buffer->count;
1285         header->type = card->lan_type;
1286         header->slot = card->portno;
1287         memcpy(header + 1, skb->data, skb->len);
1288         card->stats.tx_bytes += skb->len;
1289         card->stats.tx_packets++;
1290         dev_kfree_skb(skb);
1291         if (card->tx_emitted <= 0)
1292                 /* If this is the first tx buffer emit it immediately. */
1293                 __lcs_emit_txbuffer(card);
1294         return 0;
1295 }
1296
1297 static int
1298 lcs_start_xmit(struct sk_buff *skb, struct net_device *dev)
1299 {
1300         struct lcs_card *card;
1301         int rc;
1302
1303         LCS_DBF_TEXT(5, trace, "pktxmit");
1304         card = (struct lcs_card *) dev->priv;
1305         spin_lock(&card->lock);
1306         rc = __lcs_start_xmit(card, skb, dev);
1307         spin_unlock(&card->lock);
1308         return rc;
1309 }
1310
1311 /**
1312  * send startlan and lanstat command to make LCS device ready
1313  */
1314 static int
1315 lcs_startlan_auto(struct lcs_card *card)
1316 {
1317         int rc;
1318
1319         LCS_DBF_TEXT(2, trace, "strtauto");
1320 #ifdef CONFIG_NET_ETHERNET
1321         card->lan_type = LCS_FRAME_TYPE_ENET;
1322         rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP);
1323         if (rc == 0)
1324                 return 0;
1325
1326 #endif
1327 #ifdef CONFIG_TR
1328         card->lan_type = LCS_FRAME_TYPE_TR;
1329         rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP);
1330         if (rc == 0)
1331                 return 0;
1332 #endif
1333 #ifdef CONFIG_FDDI
1334         card->lan_type = LCS_FRAME_TYPE_FDDI;
1335         rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP);
1336         if (rc == 0)
1337                 return 0;
1338 #endif
1339         return -EIO;
1340 }
1341
1342 static int
1343 lcs_startlan(struct lcs_card *card)
1344 {
1345         int rc, i;
1346
1347         LCS_DBF_TEXT(2, trace, "startlan");
1348         rc = 0;
1349         if (card->portno != LCS_INVALID_PORT_NO) {
1350                 if (card->lan_type == LCS_FRAME_TYPE_AUTO)
1351                         rc = lcs_startlan_auto(card);
1352                 else
1353                         rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP);
1354         } else {
1355                 for (i = 0; i <= 16; i++) {
1356                         card->portno = i;
1357                         if (card->lan_type != LCS_FRAME_TYPE_AUTO)
1358                                 rc = lcs_send_startlan(card,
1359                                                        LCS_INITIATOR_TCPIP);
1360                         else
1361                                 /* autodetecting lan type */
1362                                 rc = lcs_startlan_auto(card);
1363                         if (rc == 0)
1364                                 break;
1365                 }
1366         }
1367         if (rc == 0)
1368                 return lcs_send_lanstat(card);
1369         return rc;
1370 }
1371
1372 /**
1373  * LCS detect function
1374  * setup channels and make them I/O ready
1375  */
1376 static int
1377 lcs_detect(struct lcs_card *card)
1378 {
1379         int rc = 0;
1380
1381         LCS_DBF_TEXT(2, setup, "lcsdetct");
1382         /* start/reset card */
1383         if (card->dev)
1384                 netif_stop_queue(card->dev);
1385         card->write.state = CH_STATE_INIT;
1386         card->read.state = CH_STATE_INIT;
1387         rc = lcs_stop_channels(card);
1388         if (rc == 0) {
1389                 rc = lcs_start_channels(card);
1390                 if (rc == 0) {
1391                         rc = lcs_send_startup(card, LCS_INITIATOR_TCPIP);
1392                         if (rc == 0)
1393                                 rc = lcs_startlan(card);
1394                 }
1395         }
1396         if (rc == 0) {
1397                 card->state = DEV_STATE_UP;
1398         } else {
1399                 card->state = DEV_STATE_DOWN;
1400                 card->write.state = CH_STATE_INIT;
1401                 card->read.state =  CH_STATE_INIT;
1402         }
1403         return rc;
1404 }
1405
1406 /**
1407  * reset card
1408  */
1409 static int
1410 lcs_resetcard(struct lcs_card *card)
1411 {
1412         int retries;
1413
1414         LCS_DBF_TEXT(2, trace, "rescard");
1415         for (retries = 0; retries < 10; retries++) {
1416                 if (lcs_detect(card) == 0) {
1417                         netif_wake_queue(card->dev);
1418                         card->state = DEV_STATE_UP;
1419                         PRINT_INFO("LCS device %s successfully restarted!\n",
1420                                    card->dev->name);
1421                         return 0;
1422                 }
1423                 schedule_timeout(3 * HZ);
1424         }
1425         PRINT_ERR("Error in Reseting LCS card!\n");
1426         return -EIO;
1427 }
1428
1429 /**
1430  * LCS Stop card
1431  */
1432 static int
1433 lcs_stopcard(struct lcs_card *card)
1434 {
1435         int rc;
1436
1437         LCS_DBF_TEXT(3, setup, "stopcard");
1438
1439         if (card->read.state != CH_STATE_STOPPED &&
1440             card->write.state != CH_STATE_STOPPED &&
1441             card->state == DEV_STATE_UP) {
1442                 rc = lcs_send_stoplan(card,LCS_INITIATOR_TCPIP);
1443                 rc = lcs_send_shutdown(card);
1444         }
1445         rc = lcs_stop_channels(card);
1446         card->state = DEV_STATE_DOWN;
1447
1448         return rc;
1449 }
1450
1451 /**
1452  * LGW initiated commands
1453  */
1454 static int
1455 lcs_lgw_startlan_thread(void *data)
1456 {
1457         struct lcs_card *card;
1458
1459         card = (struct lcs_card *) data;
1460         daemonize("lgwstpln");
1461         LCS_DBF_TEXT(4, trace, "lgwstpln");
1462         if (card->dev)
1463                 netif_stop_queue(card->dev);
1464         if (lcs_startlan(card) == 0) {
1465                 netif_wake_queue(card->dev);
1466                 card->state = DEV_STATE_UP;
1467                 PRINT_INFO("LCS Startlan for device %s succeeded!\n",
1468                            card->dev->name);
1469
1470         } else
1471                 PRINT_ERR("LCS Startlan for device %s failed!\n",
1472                           card->dev->name);
1473         return 0;
1474 }
1475
1476 /**
1477  * Send startup command initiated by Lan Gateway
1478  */
1479 static int
1480 lcs_lgw_startup_thread(void *data)
1481 {
1482         int rc;
1483
1484         struct lcs_card *card;
1485
1486         card = (struct lcs_card *) data;
1487         daemonize("lgwstpln");
1488         LCS_DBF_TEXT(4, trace, "lgwstpln");
1489         if (card->dev)
1490                 netif_stop_queue(card->dev);
1491         rc = lcs_send_startup(card, LCS_INITIATOR_LGW);
1492         if (rc != 0) {
1493                 PRINT_ERR("Startup for LCS device %s initiated " \
1494                           "by LGW failed!\nReseting card ...\n",
1495                           card->dev->name);
1496                 /* do a card reset */
1497                 rc = lcs_resetcard(card);
1498                 if (rc == 0)
1499                         goto Done;
1500         }
1501         rc = lcs_startlan(card);
1502         if (rc == 0) {
1503                 netif_wake_queue(card->dev);
1504                 card->state = DEV_STATE_UP;
1505         }
1506 Done:
1507         if (rc == 0)
1508                 PRINT_INFO("LCS Startup for device %s succeeded!\n",
1509                            card->dev->name);
1510         else
1511                 PRINT_ERR("LCS Startup for device %s failed!\n",
1512                           card->dev->name);
1513         return 0;
1514 }
1515
1516
1517 /**
1518  * send stoplan command initiated by Lan Gateway
1519  */
1520 static int
1521 lcs_lgw_stoplan_thread(void *data)
1522 {
1523         struct lcs_card *card;
1524         int rc;
1525
1526         card = (struct lcs_card *) data;
1527         daemonize("lgwstop");
1528         LCS_DBF_TEXT(4, trace, "lgwstop");
1529         if (card->dev)
1530                 netif_stop_queue(card->dev);
1531         if (lcs_send_stoplan(card, LCS_INITIATOR_LGW) == 0)
1532                 PRINT_INFO("Stoplan for %s initiated by LGW succeeded!\n",
1533                            card->dev->name);
1534         else
1535                 PRINT_ERR("Stoplan %s initiated by LGW failed!\n",
1536                           card->dev->name);
1537         /*Try to reset the card, stop it on failure */
1538         rc = lcs_resetcard(card);
1539         if (rc != 0)
1540                 rc = lcs_stopcard(card);
1541         return rc;
1542 }
1543
1544 /**
1545  * Kernel Thread helper functions for LGW initiated commands
1546  */
1547 static void
1548 lcs_start_kernel_thread(struct lcs_card *card)
1549 {
1550         LCS_DBF_TEXT(5, trace, "krnthrd");
1551         if (test_and_clear_bit(0, &card->thread_mask))
1552                 kernel_thread(lcs_lgw_startup_thread, (void *) card, SIGCHLD);
1553         if (test_and_clear_bit(1, &card->thread_mask))
1554                 kernel_thread(lcs_lgw_startlan_thread, (void *) card, SIGCHLD);
1555         if (test_and_clear_bit(2, &card->thread_mask))
1556                 kernel_thread(lcs_lgw_stoplan_thread, (void *) card, SIGCHLD);
1557 #ifdef CONFIG_IP_MULTICAST
1558         if (test_and_clear_bit(3, &card->thread_mask))
1559                 kernel_thread(lcs_register_mc_addresses, (void *) card, SIGCHLD);
1560 #endif
1561 }
1562
1563 /**
1564  * Process control frames.
1565  */
1566 static void
1567 lcs_get_control(struct lcs_card *card, struct lcs_cmd *cmd)
1568 {
1569         LCS_DBF_TEXT(5, trace, "getctrl");
1570         if (cmd->initiator == LCS_INITIATOR_LGW) {
1571                 switch(cmd->cmd_code) {
1572                 case LCS_CMD_STARTUP:
1573                         set_bit(0, &card->thread_mask);
1574                         schedule_work(&card->kernel_thread_starter);
1575                         break;
1576                 case LCS_CMD_STARTLAN:
1577                         set_bit(1, &card->thread_mask);
1578                         schedule_work(&card->kernel_thread_starter);
1579                         break;
1580                 case LCS_CMD_STOPLAN:
1581                         set_bit(2, &card->thread_mask);
1582                         schedule_work(&card->kernel_thread_starter);
1583                         break;
1584                 default:
1585                         PRINT_INFO("UNRECOGNIZED LGW COMMAND\n");
1586                         break;
1587                 }
1588         } else
1589                 lcs_notify_lancmd_waiters(card, cmd);
1590 }
1591
1592 /**
1593  * Unpack network packet.
1594  */
1595 static void
1596 lcs_get_skb(struct lcs_card *card, char *skb_data, unsigned int skb_len)
1597 {
1598         struct sk_buff *skb;
1599
1600         LCS_DBF_TEXT(5, trace, "getskb");
1601         if (card->dev == NULL ||
1602             card->state != DEV_STATE_UP)
1603                 /* The card isn't up. Ignore the packet. */
1604                 return;
1605
1606         skb = dev_alloc_skb(skb_len);
1607         if (skb == NULL) {
1608                 PRINT_ERR("LCS: alloc_skb failed for device=%s\n",
1609                           card->dev->name);
1610                 card->stats.rx_dropped++;
1611                 return;
1612         }
1613         skb->dev = card->dev;
1614         memcpy(skb_put(skb, skb_len), skb_data, skb_len);
1615         skb->protocol = card->lan_type_trans(skb, card->dev);
1616         card->stats.rx_bytes += skb_len;
1617         card->stats.rx_packets++;
1618         netif_rx(skb);
1619 }
1620
1621 /**
1622  * LCS main routine to get packets and lancmd replies from the buffers
1623  */
1624 static void
1625 lcs_get_frames_cb(struct lcs_channel *channel, struct lcs_buffer *buffer)
1626 {
1627         struct lcs_card *card;
1628         struct lcs_header *lcs_hdr;
1629         __u16 offset;
1630
1631         LCS_DBF_TEXT(5, trace, "lcsgtpkt");
1632         lcs_hdr = (struct lcs_header *) buffer->data;
1633         if (lcs_hdr->offset == LCS_ILLEGAL_OFFSET) {
1634                 LCS_DBF_TEXT(4, trace, "-eiogpkt");
1635                 return;
1636         }
1637         card = (struct lcs_card *)
1638                 ((char *) channel - offsetof(struct lcs_card, read));
1639         offset = 0;
1640         while (lcs_hdr->offset != 0) {
1641                 if (lcs_hdr->offset <= 0 ||
1642                     lcs_hdr->offset > LCS_IOBUFFERSIZE ||
1643                     lcs_hdr->offset < offset) {
1644                         /* Offset invalid. */
1645                         card->stats.rx_length_errors++;
1646                         card->stats.rx_errors++;
1647                         return;
1648                 }
1649                 /* What kind of frame is it? */
1650                 if (lcs_hdr->type == LCS_FRAME_TYPE_CONTROL)
1651                         /* Control frame. */
1652                         lcs_get_control(card, (struct lcs_cmd *) lcs_hdr);
1653                 else if (lcs_hdr->type == LCS_FRAME_TYPE_ENET ||
1654                          lcs_hdr->type == LCS_FRAME_TYPE_TR ||
1655                          lcs_hdr->type == LCS_FRAME_TYPE_FDDI)
1656                         /* Normal network packet. */
1657                         lcs_get_skb(card, (char *)(lcs_hdr + 1),
1658                                     lcs_hdr->offset - offset -
1659                                     sizeof(struct lcs_header));
1660                 else
1661                         /* Unknown frame type. */
1662                         ; // FIXME: error message ?
1663                 /* Proceed to next frame. */
1664                 offset = lcs_hdr->offset;
1665                 lcs_hdr->offset = LCS_ILLEGAL_OFFSET;
1666                 lcs_hdr = (struct lcs_header *) (buffer->data + offset);
1667         }
1668         /* The buffer is now empty. Make it ready again. */
1669         lcs_ready_buffer(&card->read, buffer);
1670 }
1671
1672 /**
1673  * get network statistics for ifconfig and other user programs
1674  */
1675 static struct net_device_stats *
1676 lcs_getstats(struct net_device *dev)
1677 {
1678         struct lcs_card *card;
1679
1680         LCS_DBF_TEXT(4, trace, "netstats");
1681         card = (struct lcs_card *) dev->priv;
1682         return &card->stats;
1683 }
1684
1685 /**
1686  * stop lcs device
1687  * This function will be called by user doing ifconfig xxx down
1688  */
1689 static int
1690 lcs_stop_device(struct net_device *dev)
1691 {
1692         struct lcs_card *card;
1693         int rc;
1694
1695         LCS_DBF_TEXT(2, trace, "stopdev");
1696         card   = (struct lcs_card *) dev->priv;
1697         netif_stop_queue(dev);
1698         dev->flags &= ~IFF_UP;
1699         rc = lcs_stopcard(card);
1700         if (rc)
1701                 PRINT_ERR("Try it again!\n ");
1702         return rc;
1703 }
1704
1705 /**
1706  * start lcs device and make it runnable
1707  * This function will be called by user doing ifconfig xxx up
1708  */
1709 static int
1710 lcs_open_device(struct net_device *dev)
1711 {
1712         struct lcs_card *card;
1713         int rc;
1714
1715         LCS_DBF_TEXT(2, trace, "opendev");
1716         card = (struct lcs_card *) dev->priv;
1717         /* initialize statistics */
1718         rc = lcs_detect(card);
1719         if (rc) {
1720                 PRINT_ERR("LCS:Error in opening device!\n");
1721
1722         } else {
1723                 dev->flags |= IFF_UP;
1724                 netif_wake_queue(dev);
1725                 card->state = DEV_STATE_UP;
1726         }
1727         return rc;
1728 }
1729
1730 /**
1731  * show function for portno called by cat or similar things
1732  */
1733 static ssize_t
1734 lcs_portno_show (struct device *dev, char *buf)
1735 {
1736         struct lcs_card *card;
1737
1738         card = (struct lcs_card *)dev->driver_data;
1739
1740         if (!card)
1741                 return 0;
1742
1743         return sprintf(buf, "%d\n", card->portno);
1744 }
1745
1746 /**
1747  * store the value which is piped to file portno
1748  */
1749 static ssize_t
1750 lcs_portno_store (struct device *dev, const char *buf, size_t count)
1751 {
1752         struct lcs_card *card;
1753         int value;
1754
1755         card = (struct lcs_card *)dev->driver_data;
1756
1757         if (!card)
1758                 return 0;
1759
1760         sscanf(buf, "%u", &value);
1761         /* TODO: sanity checks */
1762         card->portno = value;
1763
1764         return count;
1765
1766 }
1767
1768 static DEVICE_ATTR(portno, 0644, lcs_portno_show, lcs_portno_store);
1769
1770 static ssize_t
1771 lcs_type_show(struct device *dev, char *buf)
1772 {
1773         struct ccwgroup_device *cgdev;
1774
1775         cgdev = to_ccwgroupdev(dev);
1776         if (!cgdev)
1777                 return -ENODEV;
1778
1779         return sprintf(buf, "%s\n", cu3088_type[cgdev->cdev[0]->id.driver_info]);
1780 }
1781
1782 static DEVICE_ATTR(type, 0444, lcs_type_show, NULL);
1783
1784 static ssize_t
1785 lcs_timeout_show(struct device *dev, char *buf)
1786 {
1787         struct lcs_card *card;
1788
1789         card = (struct lcs_card *)dev->driver_data;
1790
1791         return card ? sprintf(buf, "%u\n", card->lancmd_timeout) : 0;
1792 }
1793
1794 static ssize_t
1795 lcs_timeout_store (struct device *dev, const char *buf, size_t count)
1796 {
1797         struct lcs_card *card;
1798         int value;
1799
1800         card = (struct lcs_card *)dev->driver_data;
1801
1802         if (!card)
1803                 return 0;
1804
1805         sscanf(buf, "%u", &value);
1806         /* TODO: sanity checks */
1807         card->lancmd_timeout = value;
1808
1809         return count;
1810
1811 }
1812
1813 DEVICE_ATTR(lancmd_timeout, 0644, lcs_timeout_show, lcs_timeout_store);
1814
1815 static struct attribute * lcs_attrs[] = {
1816         &dev_attr_portno.attr,
1817         &dev_attr_type.attr,
1818         &dev_attr_lancmd_timeout.attr,
1819         NULL,
1820 };
1821
1822 static struct attribute_group lcs_attr_group = {
1823         .attrs = lcs_attrs,
1824 };
1825
1826 /**
1827  * lcs_probe_device is called on establishing a new ccwgroup_device.
1828  */
1829 static int
1830 lcs_probe_device(struct ccwgroup_device *ccwgdev)
1831 {
1832         struct lcs_card *card;
1833         int ret;
1834
1835         if (!get_device(&ccwgdev->dev))
1836                 return -ENODEV;
1837
1838         LCS_DBF_TEXT(2, setup, "add_dev");
1839         card = lcs_alloc_card();
1840         if (!card) {
1841                 PRINT_ERR("Allocation of lcs card failed\n");
1842                 put_device(&ccwgdev->dev);
1843                 return -ENOMEM;
1844         }
1845         ret = sysfs_create_group(&ccwgdev->dev.kobj, &lcs_attr_group);
1846         if (ret) {
1847                 PRINT_ERR("Creating attributes failed");
1848                 lcs_free_card(card);
1849                 put_device(&ccwgdev->dev);
1850                 return ret;
1851         }
1852         ccwgdev->dev.driver_data = card;
1853         ccwgdev->cdev[0]->handler = lcs_irq;
1854         ccwgdev->cdev[1]->handler = lcs_irq;
1855         return 0;
1856 }
1857
1858 static int
1859 lcs_register_netdev(struct ccwgroup_device *ccwgdev)
1860 {
1861         struct lcs_card *card;
1862
1863         LCS_DBF_TEXT(2, setup, "regnetdv");
1864         card = (struct lcs_card *)ccwgdev->dev.driver_data;
1865         if (card->dev->reg_state != NETREG_UNINITIALIZED)
1866                 return 0;
1867         SET_NETDEV_DEV(card->dev, &ccwgdev->dev);
1868         return register_netdev(card->dev);
1869 }
1870
1871 /**
1872  * lcs_new_device will be called by setting the group device online.
1873  */
1874
1875 static int
1876 lcs_new_device(struct ccwgroup_device *ccwgdev)
1877 {
1878         struct  lcs_card *card;
1879         struct net_device *dev=NULL;
1880         enum lcs_dev_states recover_state;
1881         int rc;
1882
1883         card = (struct lcs_card *)ccwgdev->dev.driver_data;
1884         if (!card)
1885                 return -ENODEV;
1886
1887         LCS_DBF_TEXT(2, setup, "newdev");
1888         LCS_DBF_HEX(3, setup, &card, sizeof(void*));
1889         card->read.ccwdev  = ccwgdev->cdev[0];
1890         card->write.ccwdev = ccwgdev->cdev[1];
1891
1892         recover_state = card->state;
1893         ccw_device_set_online(card->read.ccwdev);
1894         ccw_device_set_online(card->write.ccwdev);
1895
1896         LCS_DBF_TEXT(3, setup, "lcsnewdv");
1897
1898         lcs_setup_card(card);
1899         rc = lcs_detect(card);
1900         if (rc) {
1901                 LCS_DBF_TEXT(2, setup, "dtctfail");
1902                 PRINT_WARN("Detection of LCS card failed with return code "
1903                            "%d (0x%x)\n", rc, rc);
1904                 lcs_stopcard(card);
1905                 goto out;
1906         }
1907         if (card->dev) {
1908                 LCS_DBF_TEXT(2, setup, "samedev");
1909                 LCS_DBF_HEX(3, setup, &card, sizeof(void*));
1910                 goto netdev_out;
1911         }
1912         switch (card->lan_type) {
1913 #ifdef CONFIG_NET_ETHERNET
1914         case LCS_FRAME_TYPE_ENET:
1915                 card->lan_type_trans = eth_type_trans;
1916                 dev = alloc_etherdev(0);
1917                 break;
1918 #endif
1919 #ifdef CONFIG_TR
1920         case LCS_FRAME_TYPE_TR:
1921                 card->lan_type_trans = tr_type_trans;
1922                 dev = alloc_trdev(0);
1923                 break;
1924 #endif
1925 #ifdef CONFIG_FDDI
1926         case LCS_FRAME_TYPE_FDDI:
1927                 card->lan_type_trans = fddi_type_trans;
1928                 dev = alloc_fddidev(0);
1929                 break;
1930 #endif
1931         default:
1932                 LCS_DBF_TEXT(3, setup, "errinit");
1933                 PRINT_ERR("LCS: Initialization failed\n");
1934                 PRINT_ERR("LCS: No device found!\n");
1935                 goto out;
1936         }
1937         if (!dev)
1938                 goto out;
1939         card->dev = dev;
1940 netdev_out:
1941         card->dev->priv = card;
1942         card->dev->open = lcs_open_device;
1943         card->dev->stop = lcs_stop_device;
1944         card->dev->hard_start_xmit = lcs_start_xmit;
1945         card->dev->get_stats = lcs_getstats;
1946         SET_MODULE_OWNER(dev);
1947         if (lcs_register_netdev(ccwgdev) != 0)
1948                 goto out;
1949         memcpy(card->dev->dev_addr, card->mac, LCS_MAC_LENGTH);
1950 #ifdef CONFIG_IP_MULTICAST
1951         if (!lcs_check_multicast_support(card))
1952                 card->dev->set_multicast_list = lcs_set_multicast_list;
1953 #endif
1954         netif_stop_queue(card->dev);
1955         if (recover_state == DEV_STATE_RECOVER) {
1956                 card->dev->flags |= IFF_UP;
1957                 netif_wake_queue(card->dev);
1958                 card->state = DEV_STATE_UP;
1959         } else
1960                 lcs_stopcard(card);
1961
1962         return 0;
1963 out:
1964
1965         ccw_device_set_offline(card->read.ccwdev);
1966         ccw_device_set_offline(card->write.ccwdev);
1967         return -ENODEV;
1968 }
1969
1970 /**
1971  * lcs_shutdown_device, called when setting the group device offline.
1972  */
1973 static int
1974 lcs_shutdown_device(struct ccwgroup_device *ccwgdev)
1975 {
1976         struct lcs_card *card;
1977         enum lcs_dev_states recover_state;
1978         int ret;
1979
1980         LCS_DBF_TEXT(3, setup, "shtdndev");
1981         card = (struct lcs_card *)ccwgdev->dev.driver_data;
1982         if (!card)
1983                 return -ENODEV;
1984
1985         LCS_DBF_HEX(3, setup, &card, sizeof(void*));
1986         recover_state = card->state;
1987
1988         ret = lcs_stop_device(card->dev);
1989         ret = ccw_device_set_offline(card->read.ccwdev);
1990         ret = ccw_device_set_offline(card->write.ccwdev);
1991         if (recover_state == DEV_STATE_UP) {
1992                 card->state = DEV_STATE_RECOVER;
1993         }
1994         if (ret)
1995                 return ret;
1996         return 0;
1997 }
1998
1999 /**
2000  * lcs_remove_device, free buffers and card
2001  */
2002 static void
2003 lcs_remove_device(struct ccwgroup_device *ccwgdev)
2004 {
2005         struct lcs_card *card;
2006
2007         card = (struct lcs_card *)ccwgdev->dev.driver_data;
2008         if (!card)
2009                 return;
2010
2011         PRINT_INFO("Removing lcs group device ....\n");
2012         LCS_DBF_TEXT(3, setup, "remdev");
2013         LCS_DBF_HEX(3, setup, &card, sizeof(void*));
2014         if (ccwgdev->state == CCWGROUP_ONLINE) {
2015                 lcs_shutdown_device(ccwgdev);
2016         }
2017         if (card->dev)
2018                 unregister_netdev(card->dev);
2019         sysfs_remove_group(&ccwgdev->dev.kobj, &lcs_attr_group);
2020         lcs_cleanup_card(card);
2021         lcs_free_card(card);
2022         put_device(&ccwgdev->dev);
2023 }
2024
2025 /**
2026  * LCS ccwgroup driver registration
2027  */
2028 static struct ccwgroup_driver lcs_group_driver = {
2029         .owner       = THIS_MODULE,
2030         .name        = "lcs",
2031         .max_slaves  = 2,
2032         .driver_id   = 0xD3C3E2,
2033         .probe       = lcs_probe_device,
2034         .remove      = lcs_remove_device,
2035         .set_online  = lcs_new_device,
2036         .set_offline = lcs_shutdown_device,
2037 };
2038
2039 /**
2040  *  LCS Module/Kernel initialization function
2041  */
2042 static int
2043 __init lcs_init_module(void)
2044 {
2045         int rc;
2046
2047         PRINT_INFO("Loading %s\n",version);
2048         rc = lcs_register_debug_facility();
2049         LCS_DBF_TEXT(0, setup, "lcsinit");
2050         if (rc) {
2051                 PRINT_ERR("Initialization failed\n");
2052                 return rc;
2053         }
2054
2055         rc = register_cu3088_discipline(&lcs_group_driver);
2056         if (rc) {
2057                 PRINT_ERR("Initialization failed\n");
2058                 return rc;
2059         }
2060
2061         return 0;
2062 }
2063
2064
2065 /**
2066  *  LCS module cleanup function
2067  */
2068 static void
2069 __exit lcs_cleanup_module(void)
2070 {
2071         PRINT_INFO("Terminating lcs module.\n");
2072         LCS_DBF_TEXT(0, trace, "cleanup");
2073         unregister_cu3088_discipline(&lcs_group_driver);
2074         lcs_unregister_debug_facility();
2075 }
2076
2077 module_init(lcs_init_module);
2078 module_exit(lcs_cleanup_module);
2079
2080 MODULE_AUTHOR("Frank Pavlic <pavlic@de.ibm.com>");
2081 MODULE_LICENSE("GPL");
2082