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