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