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