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