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 47 static char version[] __initdata = "LCS driver"; 48 49 /* 50 * the root device for lcs group devices 51 */ 52 static struct device *lcs_root_dev; 53 54 /* 55 * Some prototypes. 56 */ 57 static void lcs_tasklet(unsigned long); 58 static void lcs_start_kernel_thread(struct work_struct *); 59 static void lcs_get_frames_cb(struct lcs_channel *, struct lcs_buffer *); 60 #ifdef CONFIG_IP_MULTICAST 61 static int lcs_send_delipm(struct lcs_card *, struct lcs_ipm_list *); 62 #endif /* CONFIG_IP_MULTICAST */ 63 static int lcs_recovery(void *ptr); 64 65 /* 66 * Debug Facility Stuff 67 */ 68 static char debug_buffer[255]; 69 static debug_info_t *lcs_dbf_setup; 70 static debug_info_t *lcs_dbf_trace; 71 72 /* 73 * LCS Debug Facility functions 74 */ 75 static void 76 lcs_unregister_debug_facility(void) 77 { 78 debug_unregister(lcs_dbf_setup); 79 debug_unregister(lcs_dbf_trace); 80 } 81 82 static int 83 lcs_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 */ 102 static int 103 lcs_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 */ 129 static void 130 lcs_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 */ 144 static void 145 lcs_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 */ 157 static void 158 lcs_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 */ 168 static struct lcs_card * 169 lcs_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 */ 208 static void 209 lcs_setup_read_ccws(struct lcs_card *card) 210 { 211 int cnt; 212 213 LCS_DBF_TEXT(2, setup, "ireadccw"); 214 /* Setup read ccws. */ 215 memset(card->read.ccws, 0, sizeof (struct ccw1) * (LCS_NUM_BUFFS + 1)); 216 for (cnt = 0; cnt < LCS_NUM_BUFFS; cnt++) { 217 card->read.ccws[cnt].cmd_code = LCS_CCW_READ; 218 card->read.ccws[cnt].count = LCS_IOBUFFERSIZE; 219 card->read.ccws[cnt].flags = 220 CCW_FLAG_CC | CCW_FLAG_SLI | CCW_FLAG_PCI; 221 /* 222 * Note: we have allocated the buffer with GFP_DMA, so 223 * we do not need to do set_normalized_cda. 224 */ 225 card->read.ccws[cnt].cda = 226 (__u32) __pa(card->read.iob[cnt].data); 227 ((struct lcs_header *) 228 card->read.iob[cnt].data)->offset = LCS_ILLEGAL_OFFSET; 229 card->read.iob[cnt].callback = lcs_get_frames_cb; 230 card->read.iob[cnt].state = LCS_BUF_STATE_READY; 231 card->read.iob[cnt].count = LCS_IOBUFFERSIZE; 232 } 233 card->read.ccws[0].flags &= ~CCW_FLAG_PCI; 234 card->read.ccws[LCS_NUM_BUFFS - 1].flags &= ~CCW_FLAG_PCI; 235 card->read.ccws[LCS_NUM_BUFFS - 1].flags |= CCW_FLAG_SUSPEND; 236 /* Last ccw is a tic (transfer in channel). */ 237 card->read.ccws[LCS_NUM_BUFFS].cmd_code = LCS_CCW_TRANSFER; 238 card->read.ccws[LCS_NUM_BUFFS].cda = 239 (__u32) __pa(card->read.ccws); 240 /* Setg initial state of the read channel. */ 241 card->read.state = LCS_CH_STATE_INIT; 242 243 card->read.io_idx = 0; 244 card->read.buf_idx = 0; 245 } 246 247 static void 248 lcs_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 */ 263 static void 264 lcs_setup_write_ccws(struct lcs_card *card) 265 { 266 int cnt; 267 268 LCS_DBF_TEXT(3, setup, "iwritccw"); 269 /* Setup write ccws. */ 270 memset(card->write.ccws, 0, sizeof(struct ccw1) * (LCS_NUM_BUFFS + 1)); 271 for (cnt = 0; cnt < LCS_NUM_BUFFS; cnt++) { 272 card->write.ccws[cnt].cmd_code = LCS_CCW_WRITE; 273 card->write.ccws[cnt].count = 0; 274 card->write.ccws[cnt].flags = 275 CCW_FLAG_SUSPEND | CCW_FLAG_CC | CCW_FLAG_SLI; 276 /* 277 * Note: we have allocated the buffer with GFP_DMA, so 278 * we do not need to do set_normalized_cda. 279 */ 280 card->write.ccws[cnt].cda = 281 (__u32) __pa(card->write.iob[cnt].data); 282 } 283 /* Last ccw is a tic (transfer in channel). */ 284 card->write.ccws[LCS_NUM_BUFFS].cmd_code = LCS_CCW_TRANSFER; 285 card->write.ccws[LCS_NUM_BUFFS].cda = 286 (__u32) __pa(card->write.ccws); 287 /* Set initial state of the write channel. */ 288 card->read.state = LCS_CH_STATE_INIT; 289 290 card->write.io_idx = 0; 291 card->write.buf_idx = 0; 292 } 293 294 static void 295 lcs_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 307 static void 308 lcs_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 } 317 static 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 328 static int 329 lcs_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 335 static 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 350 static void 351 lcs_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 361 static 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 380 static int 381 lcs_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 389 static int 390 lcs_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 */ 408 static void 409 lcs_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 431 static 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 */ 458 static void 459 lcs_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 */ 475 static int 476 lcs_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 499 static int 500 lcs_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 */ 524 static int 525 lcs_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 */ 552 static int 553 lcs_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 */ 572 static int 573 lcs_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 */ 584 static 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 601 static struct lcs_buffer * 602 lcs_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 */ 617 static 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 */ 643 static 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 661 static int 662 lcs_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 */ 687 static 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 */ 719 static void 720 lcs_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 */ 735 static struct lcs_buffer * 736 lcs_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 757 static void 758 lcs_get_reply(struct lcs_reply *reply) 759 { 760 refcount_inc(&reply->refcnt); 761 } 762 763 static void 764 lcs_put_reply(struct lcs_reply *reply) 765 { 766 if (refcount_dec_and_test(&reply->refcnt)) 767 kfree(reply); 768 } 769 770 static struct lcs_reply * 771 lcs_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 */ 792 static void 793 lcs_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 */ 820 static void 821 lcs_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 845 static int 846 lcs_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 */ 884 static int 885 lcs_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 */ 902 static int 903 lcs_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 */ 919 static 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 926 static int 927 lcs_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 */ 946 static int 947 lcs_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 */ 965 static 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 973 static int 974 lcs_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 */ 993 static int 994 lcs_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 */ 1017 static int 1018 lcs_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 */ 1041 static 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 1051 static int 1052 lcs_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 */ 1081 static void 1082 lcs_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); 1092 list_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 */ 1136 static void 1137 lcs_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 */ 1146 static 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 1173 static 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 1196 static 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 1228 static int 1229 lcs_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 } 1258 out: 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 */ 1268 static void 1269 lcs_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 1282 static long 1283 lcs_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 1311 static int 1312 lcs_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 1351 static void 1352 lcs_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 */ 1362 static void 1363 lcs_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 */ 1446 static void 1447 lcs_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 */ 1483 static 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 */ 1497 static void 1498 lcs_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 */ 1522 static int 1523 __lcs_start_xmit(struct lcs_card *card, struct sk_buff *skb, 1524 struct net_device *dev) 1525 { 1526 struct lcs_header *header; 1527 int rc = NETDEV_TX_OK; 1528 1529 LCS_DBF_TEXT(5, trace, "hardxmit"); 1530 if (skb == NULL) { 1531 card->stats.tx_dropped++; 1532 card->stats.tx_errors++; 1533 return NETDEV_TX_OK; 1534 } 1535 if (card->state != DEV_STATE_UP) { 1536 dev_kfree_skb(skb); 1537 card->stats.tx_dropped++; 1538 card->stats.tx_errors++; 1539 card->stats.tx_carrier_errors++; 1540 return NETDEV_TX_OK; 1541 } 1542 if (skb->protocol == htons(ETH_P_IPV6)) { 1543 dev_kfree_skb(skb); 1544 return NETDEV_TX_OK; 1545 } 1546 netif_stop_queue(card->dev); 1547 spin_lock(&card->lock); 1548 if (card->tx_buffer != NULL && 1549 card->tx_buffer->count + sizeof(struct lcs_header) + 1550 skb->len + sizeof(u16) > LCS_IOBUFFERSIZE) 1551 /* skb too big for current tx buffer. */ 1552 __lcs_emit_txbuffer(card); 1553 if (card->tx_buffer == NULL) { 1554 /* Get new tx buffer */ 1555 card->tx_buffer = lcs_get_buffer(&card->write); 1556 if (card->tx_buffer == NULL) { 1557 card->stats.tx_dropped++; 1558 rc = NETDEV_TX_BUSY; 1559 goto out; 1560 } 1561 card->tx_buffer->callback = lcs_txbuffer_cb; 1562 card->tx_buffer->count = 0; 1563 } 1564 header = (struct lcs_header *) 1565 (card->tx_buffer->data + card->tx_buffer->count); 1566 card->tx_buffer->count += skb->len + sizeof(struct lcs_header); 1567 header->offset = card->tx_buffer->count; 1568 header->type = card->lan_type; 1569 header->slot = card->portno; 1570 skb_copy_from_linear_data(skb, header + 1, skb->len); 1571 spin_unlock(&card->lock); 1572 card->stats.tx_bytes += skb->len; 1573 card->stats.tx_packets++; 1574 dev_kfree_skb(skb); 1575 netif_wake_queue(card->dev); 1576 spin_lock(&card->lock); 1577 if (card->tx_emitted <= 0 && card->tx_buffer != NULL) 1578 /* If this is the first tx buffer emit it immediately. */ 1579 __lcs_emit_txbuffer(card); 1580 out: 1581 spin_unlock(&card->lock); 1582 return rc; 1583 } 1584 1585 static int 1586 lcs_start_xmit(struct sk_buff *skb, struct net_device *dev) 1587 { 1588 struct lcs_card *card; 1589 int rc; 1590 1591 LCS_DBF_TEXT(5, trace, "pktxmit"); 1592 card = (struct lcs_card *) dev->ml_priv; 1593 rc = __lcs_start_xmit(card, skb, dev); 1594 return rc; 1595 } 1596 1597 /* 1598 * send startlan and lanstat command to make LCS device ready 1599 */ 1600 static int 1601 lcs_startlan_auto(struct lcs_card *card) 1602 { 1603 int rc; 1604 1605 LCS_DBF_TEXT(2, trace, "strtauto"); 1606 #ifdef CONFIG_ETHERNET 1607 card->lan_type = LCS_FRAME_TYPE_ENET; 1608 rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP); 1609 if (rc == 0) 1610 return 0; 1611 1612 #endif 1613 #ifdef CONFIG_FDDI 1614 card->lan_type = LCS_FRAME_TYPE_FDDI; 1615 rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP); 1616 if (rc == 0) 1617 return 0; 1618 #endif 1619 return -EIO; 1620 } 1621 1622 static int 1623 lcs_startlan(struct lcs_card *card) 1624 { 1625 int rc, i; 1626 1627 LCS_DBF_TEXT(2, trace, "startlan"); 1628 rc = 0; 1629 if (card->portno != LCS_INVALID_PORT_NO) { 1630 if (card->lan_type == LCS_FRAME_TYPE_AUTO) 1631 rc = lcs_startlan_auto(card); 1632 else 1633 rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP); 1634 } else { 1635 for (i = 0; i <= 16; i++) { 1636 card->portno = i; 1637 if (card->lan_type != LCS_FRAME_TYPE_AUTO) 1638 rc = lcs_send_startlan(card, 1639 LCS_INITIATOR_TCPIP); 1640 else 1641 /* autodetecting lan type */ 1642 rc = lcs_startlan_auto(card); 1643 if (rc == 0) 1644 break; 1645 } 1646 } 1647 if (rc == 0) 1648 return lcs_send_lanstat(card); 1649 return rc; 1650 } 1651 1652 /* 1653 * LCS detect function 1654 * setup channels and make them I/O ready 1655 */ 1656 static int 1657 lcs_detect(struct lcs_card *card) 1658 { 1659 int rc = 0; 1660 1661 LCS_DBF_TEXT(2, setup, "lcsdetct"); 1662 /* start/reset card */ 1663 if (card->dev) 1664 netif_stop_queue(card->dev); 1665 rc = lcs_stop_channels(card); 1666 if (rc == 0) { 1667 rc = lcs_start_channels(card); 1668 if (rc == 0) { 1669 rc = lcs_send_startup(card, LCS_INITIATOR_TCPIP); 1670 if (rc == 0) 1671 rc = lcs_startlan(card); 1672 } 1673 } 1674 if (rc == 0) { 1675 card->state = DEV_STATE_UP; 1676 } else { 1677 card->state = DEV_STATE_DOWN; 1678 card->write.state = LCS_CH_STATE_INIT; 1679 card->read.state = LCS_CH_STATE_INIT; 1680 } 1681 return rc; 1682 } 1683 1684 /* 1685 * LCS Stop card 1686 */ 1687 static int 1688 lcs_stopcard(struct lcs_card *card) 1689 { 1690 int rc; 1691 1692 LCS_DBF_TEXT(3, setup, "stopcard"); 1693 1694 if (card->read.state != LCS_CH_STATE_STOPPED && 1695 card->write.state != LCS_CH_STATE_STOPPED && 1696 card->read.state != LCS_CH_STATE_ERROR && 1697 card->write.state != LCS_CH_STATE_ERROR && 1698 card->state == DEV_STATE_UP) { 1699 lcs_clear_multicast_list(card); 1700 rc = lcs_send_stoplan(card,LCS_INITIATOR_TCPIP); 1701 rc = lcs_send_shutdown(card); 1702 } 1703 rc = lcs_stop_channels(card); 1704 card->state = DEV_STATE_DOWN; 1705 1706 return rc; 1707 } 1708 1709 /* 1710 * Kernel Thread helper functions for LGW initiated commands 1711 */ 1712 static void 1713 lcs_start_kernel_thread(struct work_struct *work) 1714 { 1715 struct lcs_card *card = container_of(work, struct lcs_card, kernel_thread_starter); 1716 LCS_DBF_TEXT(5, trace, "krnthrd"); 1717 if (lcs_do_start_thread(card, LCS_RECOVERY_THREAD)) 1718 kthread_run(lcs_recovery, card, "lcs_recover"); 1719 #ifdef CONFIG_IP_MULTICAST 1720 if (lcs_do_start_thread(card, LCS_SET_MC_THREAD)) 1721 kthread_run(lcs_register_mc_addresses, card, "regipm"); 1722 #endif 1723 } 1724 1725 /* 1726 * Process control frames. 1727 */ 1728 static void 1729 lcs_get_control(struct lcs_card *card, struct lcs_cmd *cmd) 1730 { 1731 LCS_DBF_TEXT(5, trace, "getctrl"); 1732 if (cmd->initiator == LCS_INITIATOR_LGW) { 1733 switch(cmd->cmd_code) { 1734 case LCS_CMD_STARTUP: 1735 case LCS_CMD_STARTLAN: 1736 lcs_schedule_recovery(card); 1737 break; 1738 case LCS_CMD_STOPLAN: 1739 pr_warn("Stoplan for %s initiated by LGW\n", 1740 card->dev->name); 1741 if (card->dev) 1742 netif_carrier_off(card->dev); 1743 break; 1744 default: 1745 LCS_DBF_TEXT(5, trace, "noLGWcmd"); 1746 break; 1747 } 1748 } else 1749 lcs_notify_lancmd_waiters(card, cmd); 1750 } 1751 1752 /* 1753 * Unpack network packet. 1754 */ 1755 static void 1756 lcs_get_skb(struct lcs_card *card, char *skb_data, unsigned int skb_len) 1757 { 1758 struct sk_buff *skb; 1759 1760 LCS_DBF_TEXT(5, trace, "getskb"); 1761 if (card->dev == NULL || 1762 card->state != DEV_STATE_UP) 1763 /* The card isn't up. Ignore the packet. */ 1764 return; 1765 1766 skb = dev_alloc_skb(skb_len); 1767 if (skb == NULL) { 1768 dev_err(&card->dev->dev, 1769 " Allocating a socket buffer to interface %s failed\n", 1770 card->dev->name); 1771 card->stats.rx_dropped++; 1772 return; 1773 } 1774 skb_put_data(skb, skb_data, skb_len); 1775 skb->protocol = card->lan_type_trans(skb, card->dev); 1776 card->stats.rx_bytes += skb_len; 1777 card->stats.rx_packets++; 1778 if (skb->protocol == htons(ETH_P_802_2)) 1779 *((__u32 *)skb->cb) = ++card->pkt_seq; 1780 netif_rx(skb); 1781 } 1782 1783 /* 1784 * LCS main routine to get packets and lancmd replies from the buffers 1785 */ 1786 static void 1787 lcs_get_frames_cb(struct lcs_channel *channel, struct lcs_buffer *buffer) 1788 { 1789 struct lcs_card *card; 1790 struct lcs_header *lcs_hdr; 1791 __u16 offset; 1792 1793 LCS_DBF_TEXT(5, trace, "lcsgtpkt"); 1794 lcs_hdr = (struct lcs_header *) buffer->data; 1795 if (lcs_hdr->offset == LCS_ILLEGAL_OFFSET) { 1796 LCS_DBF_TEXT(4, trace, "-eiogpkt"); 1797 return; 1798 } 1799 card = container_of(channel, struct lcs_card, read); 1800 offset = 0; 1801 while (lcs_hdr->offset != 0) { 1802 if (lcs_hdr->offset <= 0 || 1803 lcs_hdr->offset > LCS_IOBUFFERSIZE || 1804 lcs_hdr->offset < offset) { 1805 /* Offset invalid. */ 1806 card->stats.rx_length_errors++; 1807 card->stats.rx_errors++; 1808 return; 1809 } 1810 /* What kind of frame is it? */ 1811 if (lcs_hdr->type == LCS_FRAME_TYPE_CONTROL) 1812 /* Control frame. */ 1813 lcs_get_control(card, (struct lcs_cmd *) lcs_hdr); 1814 else if (lcs_hdr->type == LCS_FRAME_TYPE_ENET || 1815 lcs_hdr->type == LCS_FRAME_TYPE_TR || 1816 lcs_hdr->type == LCS_FRAME_TYPE_FDDI) 1817 /* Normal network packet. */ 1818 lcs_get_skb(card, (char *)(lcs_hdr + 1), 1819 lcs_hdr->offset - offset - 1820 sizeof(struct lcs_header)); 1821 else 1822 /* Unknown frame type. */ 1823 ; // FIXME: error message ? 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 */ 1836 static struct net_device_stats * 1837 lcs_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 */ 1850 static int 1851 lcs_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 */ 1874 static int 1875 lcs_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 */ 1899 static ssize_t 1900 lcs_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 */ 1915 static ssize_t 1916 lcs_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 1939 static DEVICE_ATTR(portno, 0644, lcs_portno_show, lcs_portno_store); 1940 1941 static 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 1950 static ssize_t 1951 lcs_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 1962 static DEVICE_ATTR(type, 0444, lcs_type_show, NULL); 1963 1964 static ssize_t 1965 lcs_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 1974 static ssize_t 1975 lcs_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 1996 static DEVICE_ATTR(lancmd_timeout, 0644, lcs_timeout_show, lcs_timeout_store); 1997 1998 static ssize_t 1999 lcs_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 2016 static DEVICE_ATTR(recover, 0200, NULL, lcs_dev_recover_store); 2017 2018 static 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 }; 2025 static struct attribute_group lcs_attr_group = { 2026 .attrs = lcs_attrs, 2027 }; 2028 static const struct attribute_group *lcs_attr_groups[] = { 2029 &lcs_attr_group, 2030 NULL, 2031 }; 2032 static 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 */ 2040 static int 2041 lcs_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 2068 static int 2069 lcs_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 */ 2084 static 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 2091 static 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 2099 static int 2100 lcs_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 2170 netdev_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; 2194 out: 2195 2196 ccw_device_set_offline(card->write.ccwdev); 2197 out_werr: 2198 ccw_device_set_offline(card->read.ccwdev); 2199 out_err: 2200 return -ENODEV; 2201 } 2202 2203 /* 2204 * lcs_shutdown_device, called when setting the group device offline. 2205 */ 2206 static 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 2238 static int 2239 lcs_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 */ 2247 static int 2248 lcs_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 */ 2278 static void 2279 lcs_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 2300 static 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 }; 2306 MODULE_DEVICE_TABLE(ccw, lcs_ids); 2307 2308 static 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 */ 2322 static 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 2334 static 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 } 2341 static DRIVER_ATTR_WO(group); 2342 2343 static struct attribute *lcs_drv_attrs[] = { 2344 &driver_attr_group.attr, 2345 NULL, 2346 }; 2347 static struct attribute_group lcs_drv_attr_group = { 2348 .attrs = lcs_drv_attrs, 2349 }; 2350 static 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 */ 2358 static 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 2381 ccwgroup_err: 2382 ccw_driver_unregister(&lcs_ccw_driver); 2383 ccw_err: 2384 root_device_unregister(lcs_root_dev); 2385 register_err: 2386 lcs_unregister_debug_facility(); 2387 out_err: 2388 pr_err("Initializing the lcs device driver failed\n"); 2389 return rc; 2390 } 2391 2392 2393 /* 2394 * LCS module cleanup function 2395 */ 2396 static 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 2407 module_init(lcs_init_module); 2408 module_exit(lcs_cleanup_module); 2409 2410 MODULE_AUTHOR("Frank Pavlic <fpavlic@de.ibm.com>"); 2411 MODULE_LICENSE("GPL"); 2412 2413