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