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 destroy_timer_on_stack(&timer); 903 LCS_DBF_TEXT_(4, trace, "rc:%d",reply->rc); 904 rc = reply->rc; 905 lcs_put_reply(reply); 906 return rc ? -EIO : 0; 907 } 908 909 /** 910 * LCS startup command 911 */ 912 static int 913 lcs_send_startup(struct lcs_card *card, __u8 initiator) 914 { 915 struct lcs_buffer *buffer; 916 struct lcs_cmd *cmd; 917 918 LCS_DBF_TEXT(2, trace, "startup"); 919 buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE); 920 cmd = (struct lcs_cmd *) buffer->data; 921 cmd->cmd_code = LCS_CMD_STARTUP; 922 cmd->initiator = initiator; 923 cmd->cmd.lcs_startup.buff_size = LCS_IOBUFFERSIZE; 924 return lcs_send_lancmd(card, buffer, NULL); 925 } 926 927 /** 928 * LCS shutdown command 929 */ 930 static int 931 lcs_send_shutdown(struct lcs_card *card) 932 { 933 struct lcs_buffer *buffer; 934 struct lcs_cmd *cmd; 935 936 LCS_DBF_TEXT(2, trace, "shutdown"); 937 buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE); 938 cmd = (struct lcs_cmd *) buffer->data; 939 cmd->cmd_code = LCS_CMD_SHUTDOWN; 940 cmd->initiator = LCS_INITIATOR_TCPIP; 941 return lcs_send_lancmd(card, buffer, NULL); 942 } 943 944 /** 945 * LCS lanstat command 946 */ 947 static void 948 __lcs_lanstat_cb(struct lcs_card *card, struct lcs_cmd *cmd) 949 { 950 LCS_DBF_TEXT(2, trace, "statcb"); 951 memcpy(card->mac, cmd->cmd.lcs_lanstat_cmd.mac_addr, LCS_MAC_LENGTH); 952 } 953 954 static int 955 lcs_send_lanstat(struct lcs_card *card) 956 { 957 struct lcs_buffer *buffer; 958 struct lcs_cmd *cmd; 959 960 LCS_DBF_TEXT(2,trace, "cmdstat"); 961 buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE); 962 cmd = (struct lcs_cmd *) buffer->data; 963 /* Setup lanstat command. */ 964 cmd->cmd_code = LCS_CMD_LANSTAT; 965 cmd->initiator = LCS_INITIATOR_TCPIP; 966 cmd->cmd.lcs_std_cmd.lan_type = card->lan_type; 967 cmd->cmd.lcs_std_cmd.portno = card->portno; 968 return lcs_send_lancmd(card, buffer, __lcs_lanstat_cb); 969 } 970 971 /** 972 * send stoplan command 973 */ 974 static int 975 lcs_send_stoplan(struct lcs_card *card, __u8 initiator) 976 { 977 struct lcs_buffer *buffer; 978 struct lcs_cmd *cmd; 979 980 LCS_DBF_TEXT(2, trace, "cmdstpln"); 981 buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE); 982 cmd = (struct lcs_cmd *) buffer->data; 983 cmd->cmd_code = LCS_CMD_STOPLAN; 984 cmd->initiator = initiator; 985 cmd->cmd.lcs_std_cmd.lan_type = card->lan_type; 986 cmd->cmd.lcs_std_cmd.portno = card->portno; 987 return lcs_send_lancmd(card, buffer, NULL); 988 } 989 990 /** 991 * send startlan command 992 */ 993 static void 994 __lcs_send_startlan_cb(struct lcs_card *card, struct lcs_cmd *cmd) 995 { 996 LCS_DBF_TEXT(2, trace, "srtlancb"); 997 card->lan_type = cmd->cmd.lcs_std_cmd.lan_type; 998 card->portno = cmd->cmd.lcs_std_cmd.portno; 999 } 1000 1001 static int 1002 lcs_send_startlan(struct lcs_card *card, __u8 initiator) 1003 { 1004 struct lcs_buffer *buffer; 1005 struct lcs_cmd *cmd; 1006 1007 LCS_DBF_TEXT(2, trace, "cmdstaln"); 1008 buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE); 1009 cmd = (struct lcs_cmd *) buffer->data; 1010 cmd->cmd_code = LCS_CMD_STARTLAN; 1011 cmd->initiator = initiator; 1012 cmd->cmd.lcs_std_cmd.lan_type = card->lan_type; 1013 cmd->cmd.lcs_std_cmd.portno = card->portno; 1014 return lcs_send_lancmd(card, buffer, __lcs_send_startlan_cb); 1015 } 1016 1017 #ifdef CONFIG_IP_MULTICAST 1018 /** 1019 * send setipm command (Multicast) 1020 */ 1021 static int 1022 lcs_send_setipm(struct lcs_card *card,struct lcs_ipm_list *ipm_list) 1023 { 1024 struct lcs_buffer *buffer; 1025 struct lcs_cmd *cmd; 1026 1027 LCS_DBF_TEXT(2, trace, "cmdsetim"); 1028 buffer = lcs_get_lancmd(card, LCS_MULTICAST_CMD_SIZE); 1029 cmd = (struct lcs_cmd *) buffer->data; 1030 cmd->cmd_code = LCS_CMD_SETIPM; 1031 cmd->initiator = LCS_INITIATOR_TCPIP; 1032 cmd->cmd.lcs_qipassist.lan_type = card->lan_type; 1033 cmd->cmd.lcs_qipassist.portno = card->portno; 1034 cmd->cmd.lcs_qipassist.version = 4; 1035 cmd->cmd.lcs_qipassist.num_ip_pairs = 1; 1036 memcpy(cmd->cmd.lcs_qipassist.lcs_ipass_ctlmsg.ip_mac_pair, 1037 &ipm_list->ipm, sizeof (struct lcs_ip_mac_pair)); 1038 LCS_DBF_TEXT_(2, trace, "%x",ipm_list->ipm.ip_addr); 1039 return lcs_send_lancmd(card, buffer, NULL); 1040 } 1041 1042 /** 1043 * send delipm command (Multicast) 1044 */ 1045 static int 1046 lcs_send_delipm(struct lcs_card *card,struct lcs_ipm_list *ipm_list) 1047 { 1048 struct lcs_buffer *buffer; 1049 struct lcs_cmd *cmd; 1050 1051 LCS_DBF_TEXT(2, trace, "cmddelim"); 1052 buffer = lcs_get_lancmd(card, LCS_MULTICAST_CMD_SIZE); 1053 cmd = (struct lcs_cmd *) buffer->data; 1054 cmd->cmd_code = LCS_CMD_DELIPM; 1055 cmd->initiator = LCS_INITIATOR_TCPIP; 1056 cmd->cmd.lcs_qipassist.lan_type = card->lan_type; 1057 cmd->cmd.lcs_qipassist.portno = card->portno; 1058 cmd->cmd.lcs_qipassist.version = 4; 1059 cmd->cmd.lcs_qipassist.num_ip_pairs = 1; 1060 memcpy(cmd->cmd.lcs_qipassist.lcs_ipass_ctlmsg.ip_mac_pair, 1061 &ipm_list->ipm, sizeof (struct lcs_ip_mac_pair)); 1062 LCS_DBF_TEXT_(2, trace, "%x",ipm_list->ipm.ip_addr); 1063 return lcs_send_lancmd(card, buffer, NULL); 1064 } 1065 1066 /** 1067 * check if multicast is supported by LCS 1068 */ 1069 static void 1070 __lcs_check_multicast_cb(struct lcs_card *card, struct lcs_cmd *cmd) 1071 { 1072 LCS_DBF_TEXT(2, trace, "chkmccb"); 1073 card->ip_assists_supported = 1074 cmd->cmd.lcs_qipassist.ip_assists_supported; 1075 card->ip_assists_enabled = 1076 cmd->cmd.lcs_qipassist.ip_assists_enabled; 1077 } 1078 1079 static int 1080 lcs_check_multicast_support(struct lcs_card *card) 1081 { 1082 struct lcs_buffer *buffer; 1083 struct lcs_cmd *cmd; 1084 int rc; 1085 1086 LCS_DBF_TEXT(2, trace, "cmdqipa"); 1087 /* Send query ipassist. */ 1088 buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE); 1089 cmd = (struct lcs_cmd *) buffer->data; 1090 cmd->cmd_code = LCS_CMD_QIPASSIST; 1091 cmd->initiator = LCS_INITIATOR_TCPIP; 1092 cmd->cmd.lcs_qipassist.lan_type = card->lan_type; 1093 cmd->cmd.lcs_qipassist.portno = card->portno; 1094 cmd->cmd.lcs_qipassist.version = 4; 1095 cmd->cmd.lcs_qipassist.num_ip_pairs = 1; 1096 rc = lcs_send_lancmd(card, buffer, __lcs_check_multicast_cb); 1097 if (rc != 0) { 1098 pr_err("Query IPAssist failed. Assuming unsupported!\n"); 1099 return -EOPNOTSUPP; 1100 } 1101 if (card->ip_assists_supported & LCS_IPASS_MULTICAST_SUPPORT) 1102 return 0; 1103 return -EOPNOTSUPP; 1104 } 1105 1106 /** 1107 * set or del multicast address on LCS card 1108 */ 1109 static void 1110 lcs_fix_multicast_list(struct lcs_card *card) 1111 { 1112 struct list_head failed_list; 1113 struct lcs_ipm_list *ipm, *tmp; 1114 unsigned long flags; 1115 int rc; 1116 1117 LCS_DBF_TEXT(4,trace, "fixipm"); 1118 INIT_LIST_HEAD(&failed_list); 1119 spin_lock_irqsave(&card->ipm_lock, flags); 1120 list_modified: 1121 list_for_each_entry_safe(ipm, tmp, &card->ipm_list, list){ 1122 switch (ipm->ipm_state) { 1123 case LCS_IPM_STATE_SET_REQUIRED: 1124 /* del from ipm_list so no one else can tamper with 1125 * this entry */ 1126 list_del_init(&ipm->list); 1127 spin_unlock_irqrestore(&card->ipm_lock, flags); 1128 rc = lcs_send_setipm(card, ipm); 1129 spin_lock_irqsave(&card->ipm_lock, flags); 1130 if (rc) { 1131 pr_info("Adding multicast address failed." 1132 " Table possibly full!\n"); 1133 /* store ipm in failed list -> will be added 1134 * to ipm_list again, so a retry will be done 1135 * during the next call of this function */ 1136 list_add_tail(&ipm->list, &failed_list); 1137 } else { 1138 ipm->ipm_state = LCS_IPM_STATE_ON_CARD; 1139 /* re-insert into ipm_list */ 1140 list_add_tail(&ipm->list, &card->ipm_list); 1141 } 1142 goto list_modified; 1143 case LCS_IPM_STATE_DEL_REQUIRED: 1144 list_del(&ipm->list); 1145 spin_unlock_irqrestore(&card->ipm_lock, flags); 1146 lcs_send_delipm(card, ipm); 1147 spin_lock_irqsave(&card->ipm_lock, flags); 1148 kfree(ipm); 1149 goto list_modified; 1150 case LCS_IPM_STATE_ON_CARD: 1151 break; 1152 } 1153 } 1154 /* re-insert all entries from the failed_list into ipm_list */ 1155 list_for_each_entry_safe(ipm, tmp, &failed_list, list) 1156 list_move_tail(&ipm->list, &card->ipm_list); 1157 1158 spin_unlock_irqrestore(&card->ipm_lock, flags); 1159 } 1160 1161 /** 1162 * get mac address for the relevant Multicast address 1163 */ 1164 static void 1165 lcs_get_mac_for_ipm(__be32 ipm, char *mac, struct net_device *dev) 1166 { 1167 LCS_DBF_TEXT(4,trace, "getmac"); 1168 ip_eth_mc_map(ipm, mac); 1169 } 1170 1171 /** 1172 * function called by net device to handle multicast address relevant things 1173 */ 1174 static inline void 1175 lcs_remove_mc_addresses(struct lcs_card *card, struct in_device *in4_dev) 1176 { 1177 struct ip_mc_list *im4; 1178 struct list_head *l; 1179 struct lcs_ipm_list *ipm; 1180 unsigned long flags; 1181 char buf[MAX_ADDR_LEN]; 1182 1183 LCS_DBF_TEXT(4, trace, "remmclst"); 1184 spin_lock_irqsave(&card->ipm_lock, flags); 1185 list_for_each(l, &card->ipm_list) { 1186 ipm = list_entry(l, struct lcs_ipm_list, list); 1187 for (im4 = rcu_dereference(in4_dev->mc_list); 1188 im4 != NULL; im4 = rcu_dereference(im4->next_rcu)) { 1189 lcs_get_mac_for_ipm(im4->multiaddr, buf, card->dev); 1190 if ( (ipm->ipm.ip_addr == im4->multiaddr) && 1191 (memcmp(buf, &ipm->ipm.mac_addr, 1192 LCS_MAC_LENGTH) == 0) ) 1193 break; 1194 } 1195 if (im4 == NULL) 1196 ipm->ipm_state = LCS_IPM_STATE_DEL_REQUIRED; 1197 } 1198 spin_unlock_irqrestore(&card->ipm_lock, flags); 1199 } 1200 1201 static inline struct lcs_ipm_list * 1202 lcs_check_addr_entry(struct lcs_card *card, struct ip_mc_list *im4, char *buf) 1203 { 1204 struct lcs_ipm_list *tmp, *ipm = NULL; 1205 struct list_head *l; 1206 unsigned long flags; 1207 1208 LCS_DBF_TEXT(4, trace, "chkmcent"); 1209 spin_lock_irqsave(&card->ipm_lock, flags); 1210 list_for_each(l, &card->ipm_list) { 1211 tmp = list_entry(l, struct lcs_ipm_list, list); 1212 if ( (tmp->ipm.ip_addr == im4->multiaddr) && 1213 (memcmp(buf, &tmp->ipm.mac_addr, 1214 LCS_MAC_LENGTH) == 0) ) { 1215 ipm = tmp; 1216 break; 1217 } 1218 } 1219 spin_unlock_irqrestore(&card->ipm_lock, flags); 1220 return ipm; 1221 } 1222 1223 static inline void 1224 lcs_set_mc_addresses(struct lcs_card *card, struct in_device *in4_dev) 1225 { 1226 1227 struct ip_mc_list *im4; 1228 struct lcs_ipm_list *ipm; 1229 char buf[MAX_ADDR_LEN]; 1230 unsigned long flags; 1231 1232 LCS_DBF_TEXT(4, trace, "setmclst"); 1233 for (im4 = rcu_dereference(in4_dev->mc_list); im4 != NULL; 1234 im4 = rcu_dereference(im4->next_rcu)) { 1235 lcs_get_mac_for_ipm(im4->multiaddr, buf, card->dev); 1236 ipm = lcs_check_addr_entry(card, im4, buf); 1237 if (ipm != NULL) 1238 continue; /* Address already in list. */ 1239 ipm = kzalloc(sizeof(struct lcs_ipm_list), GFP_ATOMIC); 1240 if (ipm == NULL) { 1241 pr_info("Not enough memory to add" 1242 " new multicast entry!\n"); 1243 break; 1244 } 1245 memcpy(&ipm->ipm.mac_addr, buf, LCS_MAC_LENGTH); 1246 ipm->ipm.ip_addr = im4->multiaddr; 1247 ipm->ipm_state = LCS_IPM_STATE_SET_REQUIRED; 1248 spin_lock_irqsave(&card->ipm_lock, flags); 1249 LCS_DBF_HEX(2,trace,&ipm->ipm.ip_addr,4); 1250 list_add(&ipm->list, &card->ipm_list); 1251 spin_unlock_irqrestore(&card->ipm_lock, flags); 1252 } 1253 } 1254 1255 static int 1256 lcs_register_mc_addresses(void *data) 1257 { 1258 struct lcs_card *card; 1259 struct in_device *in4_dev; 1260 1261 card = (struct lcs_card *) data; 1262 1263 if (!lcs_do_run_thread(card, LCS_SET_MC_THREAD)) 1264 return 0; 1265 LCS_DBF_TEXT(4, trace, "regmulti"); 1266 1267 in4_dev = in_dev_get(card->dev); 1268 if (in4_dev == NULL) 1269 goto out; 1270 rcu_read_lock(); 1271 lcs_remove_mc_addresses(card,in4_dev); 1272 lcs_set_mc_addresses(card, in4_dev); 1273 rcu_read_unlock(); 1274 in_dev_put(in4_dev); 1275 1276 netif_carrier_off(card->dev); 1277 netif_tx_disable(card->dev); 1278 wait_event(card->write.wait_q, 1279 (card->write.state != LCS_CH_STATE_RUNNING)); 1280 lcs_fix_multicast_list(card); 1281 if (card->state == DEV_STATE_UP) { 1282 netif_carrier_on(card->dev); 1283 netif_wake_queue(card->dev); 1284 } 1285 out: 1286 lcs_clear_thread_running_bit(card, LCS_SET_MC_THREAD); 1287 return 0; 1288 } 1289 #endif /* CONFIG_IP_MULTICAST */ 1290 1291 /** 1292 * function called by net device to 1293 * handle multicast address relevant things 1294 */ 1295 static void 1296 lcs_set_multicast_list(struct net_device *dev) 1297 { 1298 #ifdef CONFIG_IP_MULTICAST 1299 struct lcs_card *card; 1300 1301 LCS_DBF_TEXT(4, trace, "setmulti"); 1302 card = (struct lcs_card *) dev->ml_priv; 1303 1304 if (!lcs_set_thread_start_bit(card, LCS_SET_MC_THREAD)) 1305 schedule_work(&card->kernel_thread_starter); 1306 #endif /* CONFIG_IP_MULTICAST */ 1307 } 1308 1309 static long 1310 lcs_check_irb_error(struct ccw_device *cdev, struct irb *irb) 1311 { 1312 if (!IS_ERR(irb)) 1313 return 0; 1314 1315 switch (PTR_ERR(irb)) { 1316 case -EIO: 1317 dev_warn(&cdev->dev, 1318 "An I/O-error occurred on the LCS device\n"); 1319 LCS_DBF_TEXT(2, trace, "ckirberr"); 1320 LCS_DBF_TEXT_(2, trace, " rc%d", -EIO); 1321 break; 1322 case -ETIMEDOUT: 1323 dev_warn(&cdev->dev, 1324 "A command timed out on the LCS device\n"); 1325 LCS_DBF_TEXT(2, trace, "ckirberr"); 1326 LCS_DBF_TEXT_(2, trace, " rc%d", -ETIMEDOUT); 1327 break; 1328 default: 1329 dev_warn(&cdev->dev, 1330 "An error occurred on the LCS device, rc=%ld\n", 1331 PTR_ERR(irb)); 1332 LCS_DBF_TEXT(2, trace, "ckirberr"); 1333 LCS_DBF_TEXT(2, trace, " rc???"); 1334 } 1335 return PTR_ERR(irb); 1336 } 1337 1338 static int 1339 lcs_get_problem(struct ccw_device *cdev, struct irb *irb) 1340 { 1341 int dstat, cstat; 1342 char *sense; 1343 1344 sense = (char *) irb->ecw; 1345 cstat = irb->scsw.cmd.cstat; 1346 dstat = irb->scsw.cmd.dstat; 1347 1348 if (cstat & (SCHN_STAT_CHN_CTRL_CHK | SCHN_STAT_INTF_CTRL_CHK | 1349 SCHN_STAT_CHN_DATA_CHK | SCHN_STAT_CHAIN_CHECK | 1350 SCHN_STAT_PROT_CHECK | SCHN_STAT_PROG_CHECK)) { 1351 LCS_DBF_TEXT(2, trace, "CGENCHK"); 1352 return 1; 1353 } 1354 if (dstat & DEV_STAT_UNIT_CHECK) { 1355 if (sense[LCS_SENSE_BYTE_1] & 1356 LCS_SENSE_RESETTING_EVENT) { 1357 LCS_DBF_TEXT(2, trace, "REVIND"); 1358 return 1; 1359 } 1360 if (sense[LCS_SENSE_BYTE_0] & 1361 LCS_SENSE_CMD_REJECT) { 1362 LCS_DBF_TEXT(2, trace, "CMDREJ"); 1363 return 0; 1364 } 1365 if ((!sense[LCS_SENSE_BYTE_0]) && 1366 (!sense[LCS_SENSE_BYTE_1]) && 1367 (!sense[LCS_SENSE_BYTE_2]) && 1368 (!sense[LCS_SENSE_BYTE_3])) { 1369 LCS_DBF_TEXT(2, trace, "ZEROSEN"); 1370 return 0; 1371 } 1372 LCS_DBF_TEXT(2, trace, "DGENCHK"); 1373 return 1; 1374 } 1375 return 0; 1376 } 1377 1378 static void 1379 lcs_schedule_recovery(struct lcs_card *card) 1380 { 1381 LCS_DBF_TEXT(2, trace, "startrec"); 1382 if (!lcs_set_thread_start_bit(card, LCS_RECOVERY_THREAD)) 1383 schedule_work(&card->kernel_thread_starter); 1384 } 1385 1386 /** 1387 * IRQ Handler for LCS channels 1388 */ 1389 static void 1390 lcs_irq(struct ccw_device *cdev, unsigned long intparm, struct irb *irb) 1391 { 1392 struct lcs_card *card; 1393 struct lcs_channel *channel; 1394 int rc, index; 1395 int cstat, dstat; 1396 1397 if (lcs_check_irb_error(cdev, irb)) 1398 return; 1399 1400 card = CARD_FROM_DEV(cdev); 1401 if (card->read.ccwdev == cdev) 1402 channel = &card->read; 1403 else 1404 channel = &card->write; 1405 1406 cstat = irb->scsw.cmd.cstat; 1407 dstat = irb->scsw.cmd.dstat; 1408 LCS_DBF_TEXT_(5, trace, "Rint%s", dev_name(&cdev->dev)); 1409 LCS_DBF_TEXT_(5, trace, "%4x%4x", irb->scsw.cmd.cstat, 1410 irb->scsw.cmd.dstat); 1411 LCS_DBF_TEXT_(5, trace, "%4x%4x", irb->scsw.cmd.fctl, 1412 irb->scsw.cmd.actl); 1413 1414 /* Check for channel and device errors presented */ 1415 rc = lcs_get_problem(cdev, irb); 1416 if (rc || (dstat & DEV_STAT_UNIT_EXCEP)) { 1417 dev_warn(&cdev->dev, 1418 "The LCS device stopped because of an error," 1419 " dstat=0x%X, cstat=0x%X \n", 1420 dstat, cstat); 1421 if (rc) { 1422 channel->state = LCS_CH_STATE_ERROR; 1423 } 1424 } 1425 if (channel->state == LCS_CH_STATE_ERROR) { 1426 lcs_schedule_recovery(card); 1427 wake_up(&card->wait_q); 1428 return; 1429 } 1430 /* How far in the ccw chain have we processed? */ 1431 if ((channel->state != LCS_CH_STATE_INIT) && 1432 (irb->scsw.cmd.fctl & SCSW_FCTL_START_FUNC) && 1433 (irb->scsw.cmd.cpa != 0)) { 1434 index = (struct ccw1 *) __va((addr_t) irb->scsw.cmd.cpa) 1435 - channel->ccws; 1436 if ((irb->scsw.cmd.actl & SCSW_ACTL_SUSPENDED) || 1437 (irb->scsw.cmd.cstat & SCHN_STAT_PCI)) 1438 /* Bloody io subsystem tells us lies about cpa... */ 1439 index = (index - 1) & (LCS_NUM_BUFFS - 1); 1440 while (channel->io_idx != index) { 1441 __lcs_processed_buffer(channel, 1442 channel->iob + channel->io_idx); 1443 channel->io_idx = 1444 (channel->io_idx + 1) & (LCS_NUM_BUFFS - 1); 1445 } 1446 } 1447 1448 if ((irb->scsw.cmd.dstat & DEV_STAT_DEV_END) || 1449 (irb->scsw.cmd.dstat & DEV_STAT_CHN_END) || 1450 (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK)) 1451 /* Mark channel as stopped. */ 1452 channel->state = LCS_CH_STATE_STOPPED; 1453 else if (irb->scsw.cmd.actl & SCSW_ACTL_SUSPENDED) 1454 /* CCW execution stopped on a suspend bit. */ 1455 channel->state = LCS_CH_STATE_SUSPENDED; 1456 if (irb->scsw.cmd.fctl & SCSW_FCTL_HALT_FUNC) { 1457 if (irb->scsw.cmd.cc != 0) { 1458 ccw_device_halt(channel->ccwdev, (addr_t) channel); 1459 return; 1460 } 1461 /* The channel has been stopped by halt_IO. */ 1462 channel->state = LCS_CH_STATE_HALTED; 1463 } 1464 if (irb->scsw.cmd.fctl & SCSW_FCTL_CLEAR_FUNC) 1465 channel->state = LCS_CH_STATE_CLEARED; 1466 /* Do the rest in the tasklet. */ 1467 tasklet_schedule(&channel->irq_tasklet); 1468 } 1469 1470 /** 1471 * Tasklet for IRQ handler 1472 */ 1473 static void 1474 lcs_tasklet(unsigned long data) 1475 { 1476 unsigned long flags; 1477 struct lcs_channel *channel; 1478 struct lcs_buffer *iob; 1479 int buf_idx; 1480 1481 channel = (struct lcs_channel *) data; 1482 LCS_DBF_TEXT_(5, trace, "tlet%s", dev_name(&channel->ccwdev->dev)); 1483 1484 /* Check for processed buffers. */ 1485 iob = channel->iob; 1486 buf_idx = channel->buf_idx; 1487 while (iob[buf_idx].state == LCS_BUF_STATE_PROCESSED) { 1488 /* Do the callback thing. */ 1489 if (iob[buf_idx].callback != NULL) 1490 iob[buf_idx].callback(channel, iob + buf_idx); 1491 buf_idx = (buf_idx + 1) & (LCS_NUM_BUFFS - 1); 1492 } 1493 channel->buf_idx = buf_idx; 1494 1495 if (channel->state == LCS_CH_STATE_STOPPED) 1496 lcs_start_channel(channel); 1497 spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags); 1498 if (channel->state == LCS_CH_STATE_SUSPENDED && 1499 channel->iob[channel->io_idx].state == LCS_BUF_STATE_READY) 1500 __lcs_resume_channel(channel); 1501 spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags); 1502 1503 /* Something happened on the channel. Wake up waiters. */ 1504 wake_up(&channel->wait_q); 1505 } 1506 1507 /** 1508 * Finish current tx buffer and make it ready for transmit. 1509 */ 1510 static void 1511 __lcs_emit_txbuffer(struct lcs_card *card) 1512 { 1513 LCS_DBF_TEXT(5, trace, "emittx"); 1514 *(__u16 *)(card->tx_buffer->data + card->tx_buffer->count) = 0; 1515 card->tx_buffer->count += 2; 1516 lcs_ready_buffer(&card->write, card->tx_buffer); 1517 card->tx_buffer = NULL; 1518 card->tx_emitted++; 1519 } 1520 1521 /** 1522 * Callback for finished tx buffers. 1523 */ 1524 static void 1525 lcs_txbuffer_cb(struct lcs_channel *channel, struct lcs_buffer *buffer) 1526 { 1527 struct lcs_card *card; 1528 1529 LCS_DBF_TEXT(5, trace, "txbuffcb"); 1530 /* Put buffer back to pool. */ 1531 lcs_release_buffer(channel, buffer); 1532 card = container_of(channel, struct lcs_card, write); 1533 if (netif_queue_stopped(card->dev) && netif_carrier_ok(card->dev)) 1534 netif_wake_queue(card->dev); 1535 spin_lock(&card->lock); 1536 card->tx_emitted--; 1537 if (card->tx_emitted <= 0 && card->tx_buffer != NULL) 1538 /* 1539 * Last running tx buffer has finished. Submit partially 1540 * filled current buffer. 1541 */ 1542 __lcs_emit_txbuffer(card); 1543 spin_unlock(&card->lock); 1544 } 1545 1546 /** 1547 * Packet transmit function called by network stack 1548 */ 1549 static int 1550 __lcs_start_xmit(struct lcs_card *card, struct sk_buff *skb, 1551 struct net_device *dev) 1552 { 1553 struct lcs_header *header; 1554 int rc = NETDEV_TX_OK; 1555 1556 LCS_DBF_TEXT(5, trace, "hardxmit"); 1557 if (skb == NULL) { 1558 card->stats.tx_dropped++; 1559 card->stats.tx_errors++; 1560 return NETDEV_TX_OK; 1561 } 1562 if (card->state != DEV_STATE_UP) { 1563 dev_kfree_skb(skb); 1564 card->stats.tx_dropped++; 1565 card->stats.tx_errors++; 1566 card->stats.tx_carrier_errors++; 1567 return NETDEV_TX_OK; 1568 } 1569 if (skb->protocol == htons(ETH_P_IPV6)) { 1570 dev_kfree_skb(skb); 1571 return NETDEV_TX_OK; 1572 } 1573 netif_stop_queue(card->dev); 1574 spin_lock(&card->lock); 1575 if (card->tx_buffer != NULL && 1576 card->tx_buffer->count + sizeof(struct lcs_header) + 1577 skb->len + sizeof(u16) > LCS_IOBUFFERSIZE) 1578 /* skb too big for current tx buffer. */ 1579 __lcs_emit_txbuffer(card); 1580 if (card->tx_buffer == NULL) { 1581 /* Get new tx buffer */ 1582 card->tx_buffer = lcs_get_buffer(&card->write); 1583 if (card->tx_buffer == NULL) { 1584 card->stats.tx_dropped++; 1585 rc = NETDEV_TX_BUSY; 1586 goto out; 1587 } 1588 card->tx_buffer->callback = lcs_txbuffer_cb; 1589 card->tx_buffer->count = 0; 1590 } 1591 header = (struct lcs_header *) 1592 (card->tx_buffer->data + card->tx_buffer->count); 1593 card->tx_buffer->count += skb->len + sizeof(struct lcs_header); 1594 header->offset = card->tx_buffer->count; 1595 header->type = card->lan_type; 1596 header->slot = card->portno; 1597 skb_copy_from_linear_data(skb, header + 1, skb->len); 1598 spin_unlock(&card->lock); 1599 card->stats.tx_bytes += skb->len; 1600 card->stats.tx_packets++; 1601 dev_kfree_skb(skb); 1602 netif_wake_queue(card->dev); 1603 spin_lock(&card->lock); 1604 if (card->tx_emitted <= 0 && card->tx_buffer != NULL) 1605 /* If this is the first tx buffer emit it immediately. */ 1606 __lcs_emit_txbuffer(card); 1607 out: 1608 spin_unlock(&card->lock); 1609 return rc; 1610 } 1611 1612 static int 1613 lcs_start_xmit(struct sk_buff *skb, struct net_device *dev) 1614 { 1615 struct lcs_card *card; 1616 int rc; 1617 1618 LCS_DBF_TEXT(5, trace, "pktxmit"); 1619 card = (struct lcs_card *) dev->ml_priv; 1620 rc = __lcs_start_xmit(card, skb, dev); 1621 return rc; 1622 } 1623 1624 /** 1625 * send startlan and lanstat command to make LCS device ready 1626 */ 1627 static int 1628 lcs_startlan_auto(struct lcs_card *card) 1629 { 1630 int rc; 1631 1632 LCS_DBF_TEXT(2, trace, "strtauto"); 1633 #ifdef CONFIG_ETHERNET 1634 card->lan_type = LCS_FRAME_TYPE_ENET; 1635 rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP); 1636 if (rc == 0) 1637 return 0; 1638 1639 #endif 1640 #ifdef CONFIG_FDDI 1641 card->lan_type = LCS_FRAME_TYPE_FDDI; 1642 rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP); 1643 if (rc == 0) 1644 return 0; 1645 #endif 1646 return -EIO; 1647 } 1648 1649 static int 1650 lcs_startlan(struct lcs_card *card) 1651 { 1652 int rc, i; 1653 1654 LCS_DBF_TEXT(2, trace, "startlan"); 1655 rc = 0; 1656 if (card->portno != LCS_INVALID_PORT_NO) { 1657 if (card->lan_type == LCS_FRAME_TYPE_AUTO) 1658 rc = lcs_startlan_auto(card); 1659 else 1660 rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP); 1661 } else { 1662 for (i = 0; i <= 16; i++) { 1663 card->portno = i; 1664 if (card->lan_type != LCS_FRAME_TYPE_AUTO) 1665 rc = lcs_send_startlan(card, 1666 LCS_INITIATOR_TCPIP); 1667 else 1668 /* autodetecting lan type */ 1669 rc = lcs_startlan_auto(card); 1670 if (rc == 0) 1671 break; 1672 } 1673 } 1674 if (rc == 0) 1675 return lcs_send_lanstat(card); 1676 return rc; 1677 } 1678 1679 /** 1680 * LCS detect function 1681 * setup channels and make them I/O ready 1682 */ 1683 static int 1684 lcs_detect(struct lcs_card *card) 1685 { 1686 int rc = 0; 1687 1688 LCS_DBF_TEXT(2, setup, "lcsdetct"); 1689 /* start/reset card */ 1690 if (card->dev) 1691 netif_stop_queue(card->dev); 1692 rc = lcs_stop_channels(card); 1693 if (rc == 0) { 1694 rc = lcs_start_channels(card); 1695 if (rc == 0) { 1696 rc = lcs_send_startup(card, LCS_INITIATOR_TCPIP); 1697 if (rc == 0) 1698 rc = lcs_startlan(card); 1699 } 1700 } 1701 if (rc == 0) { 1702 card->state = DEV_STATE_UP; 1703 } else { 1704 card->state = DEV_STATE_DOWN; 1705 card->write.state = LCS_CH_STATE_INIT; 1706 card->read.state = LCS_CH_STATE_INIT; 1707 } 1708 return rc; 1709 } 1710 1711 /** 1712 * LCS Stop card 1713 */ 1714 static int 1715 lcs_stopcard(struct lcs_card *card) 1716 { 1717 int rc; 1718 1719 LCS_DBF_TEXT(3, setup, "stopcard"); 1720 1721 if (card->read.state != LCS_CH_STATE_STOPPED && 1722 card->write.state != LCS_CH_STATE_STOPPED && 1723 card->read.state != LCS_CH_STATE_ERROR && 1724 card->write.state != LCS_CH_STATE_ERROR && 1725 card->state == DEV_STATE_UP) { 1726 lcs_clear_multicast_list(card); 1727 rc = lcs_send_stoplan(card,LCS_INITIATOR_TCPIP); 1728 rc = lcs_send_shutdown(card); 1729 } 1730 rc = lcs_stop_channels(card); 1731 card->state = DEV_STATE_DOWN; 1732 1733 return rc; 1734 } 1735 1736 /** 1737 * Kernel Thread helper functions for LGW initiated commands 1738 */ 1739 static void 1740 lcs_start_kernel_thread(struct work_struct *work) 1741 { 1742 struct lcs_card *card = container_of(work, struct lcs_card, kernel_thread_starter); 1743 LCS_DBF_TEXT(5, trace, "krnthrd"); 1744 if (lcs_do_start_thread(card, LCS_RECOVERY_THREAD)) 1745 kthread_run(lcs_recovery, card, "lcs_recover"); 1746 #ifdef CONFIG_IP_MULTICAST 1747 if (lcs_do_start_thread(card, LCS_SET_MC_THREAD)) 1748 kthread_run(lcs_register_mc_addresses, card, "regipm"); 1749 #endif 1750 } 1751 1752 /** 1753 * Process control frames. 1754 */ 1755 static void 1756 lcs_get_control(struct lcs_card *card, struct lcs_cmd *cmd) 1757 { 1758 LCS_DBF_TEXT(5, trace, "getctrl"); 1759 if (cmd->initiator == LCS_INITIATOR_LGW) { 1760 switch(cmd->cmd_code) { 1761 case LCS_CMD_STARTUP: 1762 case LCS_CMD_STARTLAN: 1763 lcs_schedule_recovery(card); 1764 break; 1765 case LCS_CMD_STOPLAN: 1766 pr_warning("Stoplan for %s initiated by LGW.\n", 1767 card->dev->name); 1768 if (card->dev) 1769 netif_carrier_off(card->dev); 1770 break; 1771 default: 1772 LCS_DBF_TEXT(5, trace, "noLGWcmd"); 1773 break; 1774 } 1775 } else 1776 lcs_notify_lancmd_waiters(card, cmd); 1777 } 1778 1779 /** 1780 * Unpack network packet. 1781 */ 1782 static void 1783 lcs_get_skb(struct lcs_card *card, char *skb_data, unsigned int skb_len) 1784 { 1785 struct sk_buff *skb; 1786 1787 LCS_DBF_TEXT(5, trace, "getskb"); 1788 if (card->dev == NULL || 1789 card->state != DEV_STATE_UP) 1790 /* The card isn't up. Ignore the packet. */ 1791 return; 1792 1793 skb = dev_alloc_skb(skb_len); 1794 if (skb == NULL) { 1795 dev_err(&card->dev->dev, 1796 " Allocating a socket buffer to interface %s failed\n", 1797 card->dev->name); 1798 card->stats.rx_dropped++; 1799 return; 1800 } 1801 memcpy(skb_put(skb, skb_len), skb_data, skb_len); 1802 skb->protocol = card->lan_type_trans(skb, card->dev); 1803 card->stats.rx_bytes += skb_len; 1804 card->stats.rx_packets++; 1805 if (skb->protocol == htons(ETH_P_802_2)) 1806 *((__u32 *)skb->cb) = ++card->pkt_seq; 1807 netif_rx(skb); 1808 } 1809 1810 /** 1811 * LCS main routine to get packets and lancmd replies from the buffers 1812 */ 1813 static void 1814 lcs_get_frames_cb(struct lcs_channel *channel, struct lcs_buffer *buffer) 1815 { 1816 struct lcs_card *card; 1817 struct lcs_header *lcs_hdr; 1818 __u16 offset; 1819 1820 LCS_DBF_TEXT(5, trace, "lcsgtpkt"); 1821 lcs_hdr = (struct lcs_header *) buffer->data; 1822 if (lcs_hdr->offset == LCS_ILLEGAL_OFFSET) { 1823 LCS_DBF_TEXT(4, trace, "-eiogpkt"); 1824 return; 1825 } 1826 card = container_of(channel, struct lcs_card, read); 1827 offset = 0; 1828 while (lcs_hdr->offset != 0) { 1829 if (lcs_hdr->offset <= 0 || 1830 lcs_hdr->offset > LCS_IOBUFFERSIZE || 1831 lcs_hdr->offset < offset) { 1832 /* Offset invalid. */ 1833 card->stats.rx_length_errors++; 1834 card->stats.rx_errors++; 1835 return; 1836 } 1837 /* What kind of frame is it? */ 1838 if (lcs_hdr->type == LCS_FRAME_TYPE_CONTROL) 1839 /* Control frame. */ 1840 lcs_get_control(card, (struct lcs_cmd *) lcs_hdr); 1841 else if (lcs_hdr->type == LCS_FRAME_TYPE_ENET || 1842 lcs_hdr->type == LCS_FRAME_TYPE_TR || 1843 lcs_hdr->type == LCS_FRAME_TYPE_FDDI) 1844 /* Normal network packet. */ 1845 lcs_get_skb(card, (char *)(lcs_hdr + 1), 1846 lcs_hdr->offset - offset - 1847 sizeof(struct lcs_header)); 1848 else 1849 /* Unknown frame type. */ 1850 ; // FIXME: error message ? 1851 /* Proceed to next frame. */ 1852 offset = lcs_hdr->offset; 1853 lcs_hdr->offset = LCS_ILLEGAL_OFFSET; 1854 lcs_hdr = (struct lcs_header *) (buffer->data + offset); 1855 } 1856 /* The buffer is now empty. Make it ready again. */ 1857 lcs_ready_buffer(&card->read, buffer); 1858 } 1859 1860 /** 1861 * get network statistics for ifconfig and other user programs 1862 */ 1863 static struct net_device_stats * 1864 lcs_getstats(struct net_device *dev) 1865 { 1866 struct lcs_card *card; 1867 1868 LCS_DBF_TEXT(4, trace, "netstats"); 1869 card = (struct lcs_card *) dev->ml_priv; 1870 return &card->stats; 1871 } 1872 1873 /** 1874 * stop lcs device 1875 * This function will be called by user doing ifconfig xxx down 1876 */ 1877 static int 1878 lcs_stop_device(struct net_device *dev) 1879 { 1880 struct lcs_card *card; 1881 int rc; 1882 1883 LCS_DBF_TEXT(2, trace, "stopdev"); 1884 card = (struct lcs_card *) dev->ml_priv; 1885 netif_carrier_off(dev); 1886 netif_tx_disable(dev); 1887 dev->flags &= ~IFF_UP; 1888 wait_event(card->write.wait_q, 1889 (card->write.state != LCS_CH_STATE_RUNNING)); 1890 rc = lcs_stopcard(card); 1891 if (rc) 1892 dev_err(&card->dev->dev, 1893 " Shutting down the LCS device failed\n "); 1894 return rc; 1895 } 1896 1897 /** 1898 * start lcs device and make it runnable 1899 * This function will be called by user doing ifconfig xxx up 1900 */ 1901 static int 1902 lcs_open_device(struct net_device *dev) 1903 { 1904 struct lcs_card *card; 1905 int rc; 1906 1907 LCS_DBF_TEXT(2, trace, "opendev"); 1908 card = (struct lcs_card *) dev->ml_priv; 1909 /* initialize statistics */ 1910 rc = lcs_detect(card); 1911 if (rc) { 1912 pr_err("Error in opening device!\n"); 1913 1914 } else { 1915 dev->flags |= IFF_UP; 1916 netif_carrier_on(dev); 1917 netif_wake_queue(dev); 1918 card->state = DEV_STATE_UP; 1919 } 1920 return rc; 1921 } 1922 1923 /** 1924 * show function for portno called by cat or similar things 1925 */ 1926 static ssize_t 1927 lcs_portno_show (struct device *dev, struct device_attribute *attr, char *buf) 1928 { 1929 struct lcs_card *card; 1930 1931 card = dev_get_drvdata(dev); 1932 1933 if (!card) 1934 return 0; 1935 1936 return sprintf(buf, "%d\n", card->portno); 1937 } 1938 1939 /** 1940 * store the value which is piped to file portno 1941 */ 1942 static ssize_t 1943 lcs_portno_store (struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1944 { 1945 struct lcs_card *card; 1946 int value, rc; 1947 1948 card = dev_get_drvdata(dev); 1949 1950 if (!card) 1951 return 0; 1952 1953 rc = sscanf(buf, "%d", &value); 1954 if (rc != 1) 1955 return -EINVAL; 1956 /* TODO: sanity checks */ 1957 card->portno = value; 1958 1959 return count; 1960 1961 } 1962 1963 static DEVICE_ATTR(portno, 0644, lcs_portno_show, lcs_portno_store); 1964 1965 static const char *lcs_type[] = { 1966 "not a channel", 1967 "2216 parallel", 1968 "2216 channel", 1969 "OSA LCS card", 1970 "unknown channel type", 1971 "unsupported channel type", 1972 }; 1973 1974 static ssize_t 1975 lcs_type_show(struct device *dev, struct device_attribute *attr, char *buf) 1976 { 1977 struct ccwgroup_device *cgdev; 1978 1979 cgdev = to_ccwgroupdev(dev); 1980 if (!cgdev) 1981 return -ENODEV; 1982 1983 return sprintf(buf, "%s\n", lcs_type[cgdev->cdev[0]->id.driver_info]); 1984 } 1985 1986 static DEVICE_ATTR(type, 0444, lcs_type_show, NULL); 1987 1988 static ssize_t 1989 lcs_timeout_show(struct device *dev, struct device_attribute *attr, char *buf) 1990 { 1991 struct lcs_card *card; 1992 1993 card = dev_get_drvdata(dev); 1994 1995 return card ? sprintf(buf, "%u\n", card->lancmd_timeout) : 0; 1996 } 1997 1998 static ssize_t 1999 lcs_timeout_store (struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 2000 { 2001 struct lcs_card *card; 2002 unsigned int value; 2003 int rc; 2004 2005 card = dev_get_drvdata(dev); 2006 2007 if (!card) 2008 return 0; 2009 2010 rc = sscanf(buf, "%u", &value); 2011 if (rc != 1) 2012 return -EINVAL; 2013 /* TODO: sanity checks */ 2014 card->lancmd_timeout = value; 2015 2016 return count; 2017 2018 } 2019 2020 static DEVICE_ATTR(lancmd_timeout, 0644, lcs_timeout_show, lcs_timeout_store); 2021 2022 static ssize_t 2023 lcs_dev_recover_store(struct device *dev, struct device_attribute *attr, 2024 const char *buf, size_t count) 2025 { 2026 struct lcs_card *card = dev_get_drvdata(dev); 2027 char *tmp; 2028 int i; 2029 2030 if (!card) 2031 return -EINVAL; 2032 if (card->state != DEV_STATE_UP) 2033 return -EPERM; 2034 i = simple_strtoul(buf, &tmp, 16); 2035 if (i == 1) 2036 lcs_schedule_recovery(card); 2037 return count; 2038 } 2039 2040 static DEVICE_ATTR(recover, 0200, NULL, lcs_dev_recover_store); 2041 2042 static struct attribute * lcs_attrs[] = { 2043 &dev_attr_portno.attr, 2044 &dev_attr_type.attr, 2045 &dev_attr_lancmd_timeout.attr, 2046 &dev_attr_recover.attr, 2047 NULL, 2048 }; 2049 static struct attribute_group lcs_attr_group = { 2050 .attrs = lcs_attrs, 2051 }; 2052 static const struct attribute_group *lcs_attr_groups[] = { 2053 &lcs_attr_group, 2054 NULL, 2055 }; 2056 static const struct device_type lcs_devtype = { 2057 .name = "lcs", 2058 .groups = lcs_attr_groups, 2059 }; 2060 2061 /** 2062 * lcs_probe_device is called on establishing a new ccwgroup_device. 2063 */ 2064 static int 2065 lcs_probe_device(struct ccwgroup_device *ccwgdev) 2066 { 2067 struct lcs_card *card; 2068 2069 if (!get_device(&ccwgdev->dev)) 2070 return -ENODEV; 2071 2072 LCS_DBF_TEXT(2, setup, "add_dev"); 2073 card = lcs_alloc_card(); 2074 if (!card) { 2075 LCS_DBF_TEXT_(2, setup, " rc%d", -ENOMEM); 2076 put_device(&ccwgdev->dev); 2077 return -ENOMEM; 2078 } 2079 dev_set_drvdata(&ccwgdev->dev, card); 2080 ccwgdev->cdev[0]->handler = lcs_irq; 2081 ccwgdev->cdev[1]->handler = lcs_irq; 2082 card->gdev = ccwgdev; 2083 INIT_WORK(&card->kernel_thread_starter, lcs_start_kernel_thread); 2084 card->thread_start_mask = 0; 2085 card->thread_allowed_mask = 0; 2086 card->thread_running_mask = 0; 2087 ccwgdev->dev.type = &lcs_devtype; 2088 2089 return 0; 2090 } 2091 2092 static int 2093 lcs_register_netdev(struct ccwgroup_device *ccwgdev) 2094 { 2095 struct lcs_card *card; 2096 2097 LCS_DBF_TEXT(2, setup, "regnetdv"); 2098 card = dev_get_drvdata(&ccwgdev->dev); 2099 if (card->dev->reg_state != NETREG_UNINITIALIZED) 2100 return 0; 2101 SET_NETDEV_DEV(card->dev, &ccwgdev->dev); 2102 return register_netdev(card->dev); 2103 } 2104 2105 /** 2106 * lcs_new_device will be called by setting the group device online. 2107 */ 2108 static const struct net_device_ops lcs_netdev_ops = { 2109 .ndo_open = lcs_open_device, 2110 .ndo_stop = lcs_stop_device, 2111 .ndo_get_stats = lcs_getstats, 2112 .ndo_start_xmit = lcs_start_xmit, 2113 }; 2114 2115 static const struct net_device_ops lcs_mc_netdev_ops = { 2116 .ndo_open = lcs_open_device, 2117 .ndo_stop = lcs_stop_device, 2118 .ndo_get_stats = lcs_getstats, 2119 .ndo_start_xmit = lcs_start_xmit, 2120 .ndo_set_rx_mode = lcs_set_multicast_list, 2121 }; 2122 2123 static int 2124 lcs_new_device(struct ccwgroup_device *ccwgdev) 2125 { 2126 struct lcs_card *card; 2127 struct net_device *dev=NULL; 2128 enum lcs_dev_states recover_state; 2129 int rc; 2130 2131 card = dev_get_drvdata(&ccwgdev->dev); 2132 if (!card) 2133 return -ENODEV; 2134 2135 LCS_DBF_TEXT(2, setup, "newdev"); 2136 LCS_DBF_HEX(3, setup, &card, sizeof(void*)); 2137 card->read.ccwdev = ccwgdev->cdev[0]; 2138 card->write.ccwdev = ccwgdev->cdev[1]; 2139 2140 recover_state = card->state; 2141 rc = ccw_device_set_online(card->read.ccwdev); 2142 if (rc) 2143 goto out_err; 2144 rc = ccw_device_set_online(card->write.ccwdev); 2145 if (rc) 2146 goto out_werr; 2147 2148 LCS_DBF_TEXT(3, setup, "lcsnewdv"); 2149 2150 lcs_setup_card(card); 2151 rc = lcs_detect(card); 2152 if (rc) { 2153 LCS_DBF_TEXT(2, setup, "dtctfail"); 2154 dev_err(&card->dev->dev, 2155 "Detecting a network adapter for LCS devices" 2156 " failed with rc=%d (0x%x)\n", rc, rc); 2157 lcs_stopcard(card); 2158 goto out; 2159 } 2160 if (card->dev) { 2161 LCS_DBF_TEXT(2, setup, "samedev"); 2162 LCS_DBF_HEX(3, setup, &card, sizeof(void*)); 2163 goto netdev_out; 2164 } 2165 switch (card->lan_type) { 2166 #ifdef CONFIG_ETHERNET 2167 case LCS_FRAME_TYPE_ENET: 2168 card->lan_type_trans = eth_type_trans; 2169 dev = alloc_etherdev(0); 2170 break; 2171 #endif 2172 #ifdef CONFIG_FDDI 2173 case LCS_FRAME_TYPE_FDDI: 2174 card->lan_type_trans = fddi_type_trans; 2175 dev = alloc_fddidev(0); 2176 break; 2177 #endif 2178 default: 2179 LCS_DBF_TEXT(3, setup, "errinit"); 2180 pr_err(" Initialization failed\n"); 2181 goto out; 2182 } 2183 if (!dev) 2184 goto out; 2185 card->dev = dev; 2186 card->dev->ml_priv = card; 2187 card->dev->netdev_ops = &lcs_netdev_ops; 2188 memcpy(card->dev->dev_addr, card->mac, LCS_MAC_LENGTH); 2189 #ifdef CONFIG_IP_MULTICAST 2190 if (!lcs_check_multicast_support(card)) 2191 card->dev->netdev_ops = &lcs_mc_netdev_ops; 2192 #endif 2193 netdev_out: 2194 lcs_set_allowed_threads(card,0xffffffff); 2195 if (recover_state == DEV_STATE_RECOVER) { 2196 lcs_set_multicast_list(card->dev); 2197 card->dev->flags |= IFF_UP; 2198 netif_carrier_on(card->dev); 2199 netif_wake_queue(card->dev); 2200 card->state = DEV_STATE_UP; 2201 } else { 2202 lcs_stopcard(card); 2203 } 2204 2205 if (lcs_register_netdev(ccwgdev) != 0) 2206 goto out; 2207 2208 /* Print out supported assists: IPv6 */ 2209 pr_info("LCS device %s %s IPv6 support\n", card->dev->name, 2210 (card->ip_assists_supported & LCS_IPASS_IPV6_SUPPORT) ? 2211 "with" : "without"); 2212 /* Print out supported assist: Multicast */ 2213 pr_info("LCS device %s %s Multicast support\n", card->dev->name, 2214 (card->ip_assists_supported & LCS_IPASS_MULTICAST_SUPPORT) ? 2215 "with" : "without"); 2216 return 0; 2217 out: 2218 2219 ccw_device_set_offline(card->write.ccwdev); 2220 out_werr: 2221 ccw_device_set_offline(card->read.ccwdev); 2222 out_err: 2223 return -ENODEV; 2224 } 2225 2226 /** 2227 * lcs_shutdown_device, called when setting the group device offline. 2228 */ 2229 static int 2230 __lcs_shutdown_device(struct ccwgroup_device *ccwgdev, int recovery_mode) 2231 { 2232 struct lcs_card *card; 2233 enum lcs_dev_states recover_state; 2234 int ret = 0, ret2 = 0, ret3 = 0; 2235 2236 LCS_DBF_TEXT(3, setup, "shtdndev"); 2237 card = dev_get_drvdata(&ccwgdev->dev); 2238 if (!card) 2239 return -ENODEV; 2240 if (recovery_mode == 0) { 2241 lcs_set_allowed_threads(card, 0); 2242 if (lcs_wait_for_threads(card, LCS_SET_MC_THREAD)) 2243 return -ERESTARTSYS; 2244 } 2245 LCS_DBF_HEX(3, setup, &card, sizeof(void*)); 2246 recover_state = card->state; 2247 2248 ret = lcs_stop_device(card->dev); 2249 ret2 = ccw_device_set_offline(card->read.ccwdev); 2250 ret3 = ccw_device_set_offline(card->write.ccwdev); 2251 if (!ret) 2252 ret = (ret2) ? ret2 : ret3; 2253 if (ret) 2254 LCS_DBF_TEXT_(3, setup, "1err:%d", ret); 2255 if (recover_state == DEV_STATE_UP) { 2256 card->state = DEV_STATE_RECOVER; 2257 } 2258 return 0; 2259 } 2260 2261 static int 2262 lcs_shutdown_device(struct ccwgroup_device *ccwgdev) 2263 { 2264 return __lcs_shutdown_device(ccwgdev, 0); 2265 } 2266 2267 /** 2268 * drive lcs recovery after startup and startlan initiated by Lan Gateway 2269 */ 2270 static int 2271 lcs_recovery(void *ptr) 2272 { 2273 struct lcs_card *card; 2274 struct ccwgroup_device *gdev; 2275 int rc; 2276 2277 card = (struct lcs_card *) ptr; 2278 2279 LCS_DBF_TEXT(4, trace, "recover1"); 2280 if (!lcs_do_run_thread(card, LCS_RECOVERY_THREAD)) 2281 return 0; 2282 LCS_DBF_TEXT(4, trace, "recover2"); 2283 gdev = card->gdev; 2284 dev_warn(&gdev->dev, 2285 "A recovery process has been started for the LCS device\n"); 2286 rc = __lcs_shutdown_device(gdev, 1); 2287 rc = lcs_new_device(gdev); 2288 if (!rc) 2289 pr_info("Device %s successfully recovered!\n", 2290 card->dev->name); 2291 else 2292 pr_info("Device %s could not be recovered!\n", 2293 card->dev->name); 2294 lcs_clear_thread_running_bit(card, LCS_RECOVERY_THREAD); 2295 return 0; 2296 } 2297 2298 /** 2299 * lcs_remove_device, free buffers and card 2300 */ 2301 static void 2302 lcs_remove_device(struct ccwgroup_device *ccwgdev) 2303 { 2304 struct lcs_card *card; 2305 2306 card = dev_get_drvdata(&ccwgdev->dev); 2307 if (!card) 2308 return; 2309 2310 LCS_DBF_TEXT(3, setup, "remdev"); 2311 LCS_DBF_HEX(3, setup, &card, sizeof(void*)); 2312 if (ccwgdev->state == CCWGROUP_ONLINE) { 2313 lcs_shutdown_device(ccwgdev); 2314 } 2315 if (card->dev) 2316 unregister_netdev(card->dev); 2317 lcs_cleanup_card(card); 2318 lcs_free_card(card); 2319 dev_set_drvdata(&ccwgdev->dev, NULL); 2320 put_device(&ccwgdev->dev); 2321 } 2322 2323 static int lcs_pm_suspend(struct lcs_card *card) 2324 { 2325 if (card->dev) 2326 netif_device_detach(card->dev); 2327 lcs_set_allowed_threads(card, 0); 2328 lcs_wait_for_threads(card, 0xffffffff); 2329 if (card->state != DEV_STATE_DOWN) 2330 __lcs_shutdown_device(card->gdev, 1); 2331 return 0; 2332 } 2333 2334 static int lcs_pm_resume(struct lcs_card *card) 2335 { 2336 int rc = 0; 2337 2338 if (card->state == DEV_STATE_RECOVER) 2339 rc = lcs_new_device(card->gdev); 2340 if (card->dev) 2341 netif_device_attach(card->dev); 2342 if (rc) { 2343 dev_warn(&card->gdev->dev, "The lcs device driver " 2344 "failed to recover the device\n"); 2345 } 2346 return rc; 2347 } 2348 2349 static int lcs_prepare(struct ccwgroup_device *gdev) 2350 { 2351 return 0; 2352 } 2353 2354 static void lcs_complete(struct ccwgroup_device *gdev) 2355 { 2356 return; 2357 } 2358 2359 static int lcs_freeze(struct ccwgroup_device *gdev) 2360 { 2361 struct lcs_card *card = dev_get_drvdata(&gdev->dev); 2362 return lcs_pm_suspend(card); 2363 } 2364 2365 static int lcs_thaw(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 int lcs_restore(struct ccwgroup_device *gdev) 2372 { 2373 struct lcs_card *card = dev_get_drvdata(&gdev->dev); 2374 return lcs_pm_resume(card); 2375 } 2376 2377 static struct ccw_device_id lcs_ids[] = { 2378 {CCW_DEVICE(0x3088, 0x08), .driver_info = lcs_channel_type_parallel}, 2379 {CCW_DEVICE(0x3088, 0x1f), .driver_info = lcs_channel_type_2216}, 2380 {CCW_DEVICE(0x3088, 0x60), .driver_info = lcs_channel_type_osa2}, 2381 {}, 2382 }; 2383 MODULE_DEVICE_TABLE(ccw, lcs_ids); 2384 2385 static struct ccw_driver lcs_ccw_driver = { 2386 .driver = { 2387 .owner = THIS_MODULE, 2388 .name = "lcs", 2389 }, 2390 .ids = lcs_ids, 2391 .probe = ccwgroup_probe_ccwdev, 2392 .remove = ccwgroup_remove_ccwdev, 2393 .int_class = IRQIO_LCS, 2394 }; 2395 2396 /** 2397 * LCS ccwgroup driver registration 2398 */ 2399 static struct ccwgroup_driver lcs_group_driver = { 2400 .driver = { 2401 .owner = THIS_MODULE, 2402 .name = "lcs", 2403 }, 2404 .setup = lcs_probe_device, 2405 .remove = lcs_remove_device, 2406 .set_online = lcs_new_device, 2407 .set_offline = lcs_shutdown_device, 2408 .prepare = lcs_prepare, 2409 .complete = lcs_complete, 2410 .freeze = lcs_freeze, 2411 .thaw = lcs_thaw, 2412 .restore = lcs_restore, 2413 }; 2414 2415 static ssize_t lcs_driver_group_store(struct device_driver *ddrv, 2416 const char *buf, size_t count) 2417 { 2418 int err; 2419 err = ccwgroup_create_dev(lcs_root_dev, &lcs_group_driver, 2, buf); 2420 return err ? err : count; 2421 } 2422 static DRIVER_ATTR(group, 0200, NULL, lcs_driver_group_store); 2423 2424 static struct attribute *lcs_drv_attrs[] = { 2425 &driver_attr_group.attr, 2426 NULL, 2427 }; 2428 static struct attribute_group lcs_drv_attr_group = { 2429 .attrs = lcs_drv_attrs, 2430 }; 2431 static const struct attribute_group *lcs_drv_attr_groups[] = { 2432 &lcs_drv_attr_group, 2433 NULL, 2434 }; 2435 2436 /** 2437 * LCS Module/Kernel initialization function 2438 */ 2439 static int 2440 __init lcs_init_module(void) 2441 { 2442 int rc; 2443 2444 pr_info("Loading %s\n", version); 2445 rc = lcs_register_debug_facility(); 2446 LCS_DBF_TEXT(0, setup, "lcsinit"); 2447 if (rc) 2448 goto out_err; 2449 lcs_root_dev = root_device_register("lcs"); 2450 rc = PTR_ERR_OR_ZERO(lcs_root_dev); 2451 if (rc) 2452 goto register_err; 2453 rc = ccw_driver_register(&lcs_ccw_driver); 2454 if (rc) 2455 goto ccw_err; 2456 lcs_group_driver.driver.groups = lcs_drv_attr_groups; 2457 rc = ccwgroup_driver_register(&lcs_group_driver); 2458 if (rc) 2459 goto ccwgroup_err; 2460 return 0; 2461 2462 ccwgroup_err: 2463 ccw_driver_unregister(&lcs_ccw_driver); 2464 ccw_err: 2465 root_device_unregister(lcs_root_dev); 2466 register_err: 2467 lcs_unregister_debug_facility(); 2468 out_err: 2469 pr_err("Initializing the lcs device driver failed\n"); 2470 return rc; 2471 } 2472 2473 2474 /** 2475 * LCS module cleanup function 2476 */ 2477 static void 2478 __exit lcs_cleanup_module(void) 2479 { 2480 pr_info("Terminating lcs module.\n"); 2481 LCS_DBF_TEXT(0, trace, "cleanup"); 2482 ccwgroup_driver_unregister(&lcs_group_driver); 2483 ccw_driver_unregister(&lcs_ccw_driver); 2484 root_device_unregister(lcs_root_dev); 2485 lcs_unregister_debug_facility(); 2486 } 2487 2488 module_init(lcs_init_module); 2489 module_exit(lcs_cleanup_module); 2490 2491 MODULE_AUTHOR("Frank Pavlic <fpavlic@de.ibm.com>"); 2492 MODULE_LICENSE("GPL"); 2493 2494