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