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