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