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/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_LICENSE("GPL"); 2384 2385