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