1 /* 2 * FUJITSU Extended Socket Network Device driver 3 * Copyright (c) 2015 FUJITSU LIMITED 4 * 5 * This program is free software; you can redistribute it and/or modify it 6 * under the terms and conditions of the GNU General Public License, 7 * version 2, as published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 12 * more details. 13 * 14 * You should have received a copy of the GNU General Public License along with 15 * this program; if not, see <http://www.gnu.org/licenses/>. 16 * 17 * The full GNU General Public License is included in this distribution in 18 * the file called "COPYING". 19 * 20 */ 21 22 #include <linux/module.h> 23 #include <linux/types.h> 24 #include <linux/nls.h> 25 #include <linux/platform_device.h> 26 #include <linux/netdevice.h> 27 #include <linux/interrupt.h> 28 29 #include "fjes.h" 30 #include "fjes_trace.h" 31 32 #define MAJ 1 33 #define MIN 2 34 #define DRV_VERSION __stringify(MAJ) "." __stringify(MIN) 35 #define DRV_NAME "fjes" 36 char fjes_driver_name[] = DRV_NAME; 37 char fjes_driver_version[] = DRV_VERSION; 38 static const char fjes_driver_string[] = 39 "FUJITSU Extended Socket Network Device Driver"; 40 static const char fjes_copyright[] = 41 "Copyright (c) 2015 FUJITSU LIMITED"; 42 43 MODULE_AUTHOR("Taku Izumi <izumi.taku@jp.fujitsu.com>"); 44 MODULE_DESCRIPTION("FUJITSU Extended Socket Network Device Driver"); 45 MODULE_LICENSE("GPL"); 46 MODULE_VERSION(DRV_VERSION); 47 48 static int fjes_request_irq(struct fjes_adapter *); 49 static void fjes_free_irq(struct fjes_adapter *); 50 51 static int fjes_open(struct net_device *); 52 static int fjes_close(struct net_device *); 53 static int fjes_setup_resources(struct fjes_adapter *); 54 static void fjes_free_resources(struct fjes_adapter *); 55 static netdev_tx_t fjes_xmit_frame(struct sk_buff *, struct net_device *); 56 static void fjes_raise_intr_rxdata_task(struct work_struct *); 57 static void fjes_tx_stall_task(struct work_struct *); 58 static void fjes_force_close_task(struct work_struct *); 59 static irqreturn_t fjes_intr(int, void*); 60 static void fjes_get_stats64(struct net_device *, struct rtnl_link_stats64 *); 61 static int fjes_change_mtu(struct net_device *, int); 62 static int fjes_vlan_rx_add_vid(struct net_device *, __be16 proto, u16); 63 static int fjes_vlan_rx_kill_vid(struct net_device *, __be16 proto, u16); 64 static void fjes_tx_retry(struct net_device *); 65 66 static int fjes_acpi_add(struct acpi_device *); 67 static int fjes_acpi_remove(struct acpi_device *); 68 static acpi_status fjes_get_acpi_resource(struct acpi_resource *, void*); 69 70 static int fjes_probe(struct platform_device *); 71 static int fjes_remove(struct platform_device *); 72 73 static int fjes_sw_init(struct fjes_adapter *); 74 static void fjes_netdev_setup(struct net_device *); 75 static void fjes_irq_watch_task(struct work_struct *); 76 static void fjes_watch_unshare_task(struct work_struct *); 77 static void fjes_rx_irq(struct fjes_adapter *, int); 78 static int fjes_poll(struct napi_struct *, int); 79 80 static const struct acpi_device_id fjes_acpi_ids[] = { 81 {"PNP0C02", 0}, 82 {"", 0}, 83 }; 84 MODULE_DEVICE_TABLE(acpi, fjes_acpi_ids); 85 86 static struct acpi_driver fjes_acpi_driver = { 87 .name = DRV_NAME, 88 .class = DRV_NAME, 89 .owner = THIS_MODULE, 90 .ids = fjes_acpi_ids, 91 .ops = { 92 .add = fjes_acpi_add, 93 .remove = fjes_acpi_remove, 94 }, 95 }; 96 97 static struct platform_driver fjes_driver = { 98 .driver = { 99 .name = DRV_NAME, 100 }, 101 .probe = fjes_probe, 102 .remove = fjes_remove, 103 }; 104 105 static struct resource fjes_resource[] = { 106 { 107 .flags = IORESOURCE_MEM, 108 .start = 0, 109 .end = 0, 110 }, 111 { 112 .flags = IORESOURCE_IRQ, 113 .start = 0, 114 .end = 0, 115 }, 116 }; 117 118 static int fjes_acpi_add(struct acpi_device *device) 119 { 120 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL}; 121 char str_buf[sizeof(FJES_ACPI_SYMBOL) + 1]; 122 struct platform_device *plat_dev; 123 union acpi_object *str; 124 acpi_status status; 125 int result; 126 127 status = acpi_evaluate_object(device->handle, "_STR", NULL, &buffer); 128 if (ACPI_FAILURE(status)) 129 return -ENODEV; 130 131 str = buffer.pointer; 132 result = utf16s_to_utf8s((wchar_t *)str->string.pointer, 133 str->string.length, UTF16_LITTLE_ENDIAN, 134 str_buf, sizeof(str_buf) - 1); 135 str_buf[result] = 0; 136 137 if (strncmp(FJES_ACPI_SYMBOL, str_buf, strlen(FJES_ACPI_SYMBOL)) != 0) { 138 kfree(buffer.pointer); 139 return -ENODEV; 140 } 141 kfree(buffer.pointer); 142 143 status = acpi_walk_resources(device->handle, METHOD_NAME__CRS, 144 fjes_get_acpi_resource, fjes_resource); 145 if (ACPI_FAILURE(status)) 146 return -ENODEV; 147 148 /* create platform_device */ 149 plat_dev = platform_device_register_simple(DRV_NAME, 0, fjes_resource, 150 ARRAY_SIZE(fjes_resource)); 151 device->driver_data = plat_dev; 152 153 return 0; 154 } 155 156 static int fjes_acpi_remove(struct acpi_device *device) 157 { 158 struct platform_device *plat_dev; 159 160 plat_dev = (struct platform_device *)acpi_driver_data(device); 161 platform_device_unregister(plat_dev); 162 163 return 0; 164 } 165 166 static acpi_status 167 fjes_get_acpi_resource(struct acpi_resource *acpi_res, void *data) 168 { 169 struct acpi_resource_address32 *addr; 170 struct acpi_resource_irq *irq; 171 struct resource *res = data; 172 173 switch (acpi_res->type) { 174 case ACPI_RESOURCE_TYPE_ADDRESS32: 175 addr = &acpi_res->data.address32; 176 res[0].start = addr->address.minimum; 177 res[0].end = addr->address.minimum + 178 addr->address.address_length - 1; 179 break; 180 181 case ACPI_RESOURCE_TYPE_IRQ: 182 irq = &acpi_res->data.irq; 183 if (irq->interrupt_count != 1) 184 return AE_ERROR; 185 res[1].start = irq->interrupts[0]; 186 res[1].end = irq->interrupts[0]; 187 break; 188 189 default: 190 break; 191 } 192 193 return AE_OK; 194 } 195 196 static int fjes_request_irq(struct fjes_adapter *adapter) 197 { 198 struct net_device *netdev = adapter->netdev; 199 int result = -1; 200 201 adapter->interrupt_watch_enable = true; 202 if (!delayed_work_pending(&adapter->interrupt_watch_task)) { 203 queue_delayed_work(adapter->control_wq, 204 &adapter->interrupt_watch_task, 205 FJES_IRQ_WATCH_DELAY); 206 } 207 208 if (!adapter->irq_registered) { 209 result = request_irq(adapter->hw.hw_res.irq, fjes_intr, 210 IRQF_SHARED, netdev->name, adapter); 211 if (result) 212 adapter->irq_registered = false; 213 else 214 adapter->irq_registered = true; 215 } 216 217 return result; 218 } 219 220 static void fjes_free_irq(struct fjes_adapter *adapter) 221 { 222 struct fjes_hw *hw = &adapter->hw; 223 224 adapter->interrupt_watch_enable = false; 225 cancel_delayed_work_sync(&adapter->interrupt_watch_task); 226 227 fjes_hw_set_irqmask(hw, REG_ICTL_MASK_ALL, true); 228 229 if (adapter->irq_registered) { 230 free_irq(adapter->hw.hw_res.irq, adapter); 231 adapter->irq_registered = false; 232 } 233 } 234 235 static const struct net_device_ops fjes_netdev_ops = { 236 .ndo_open = fjes_open, 237 .ndo_stop = fjes_close, 238 .ndo_start_xmit = fjes_xmit_frame, 239 .ndo_get_stats64 = fjes_get_stats64, 240 .ndo_change_mtu = fjes_change_mtu, 241 .ndo_tx_timeout = fjes_tx_retry, 242 .ndo_vlan_rx_add_vid = fjes_vlan_rx_add_vid, 243 .ndo_vlan_rx_kill_vid = fjes_vlan_rx_kill_vid, 244 }; 245 246 /* fjes_open - Called when a network interface is made active */ 247 static int fjes_open(struct net_device *netdev) 248 { 249 struct fjes_adapter *adapter = netdev_priv(netdev); 250 struct fjes_hw *hw = &adapter->hw; 251 int result; 252 253 if (adapter->open_guard) 254 return -ENXIO; 255 256 result = fjes_setup_resources(adapter); 257 if (result) 258 goto err_setup_res; 259 260 hw->txrx_stop_req_bit = 0; 261 hw->epstop_req_bit = 0; 262 263 napi_enable(&adapter->napi); 264 265 fjes_hw_capture_interrupt_status(hw); 266 267 result = fjes_request_irq(adapter); 268 if (result) 269 goto err_req_irq; 270 271 fjes_hw_set_irqmask(hw, REG_ICTL_MASK_ALL, false); 272 273 netif_tx_start_all_queues(netdev); 274 netif_carrier_on(netdev); 275 276 return 0; 277 278 err_req_irq: 279 fjes_free_irq(adapter); 280 napi_disable(&adapter->napi); 281 282 err_setup_res: 283 fjes_free_resources(adapter); 284 return result; 285 } 286 287 /* fjes_close - Disables a network interface */ 288 static int fjes_close(struct net_device *netdev) 289 { 290 struct fjes_adapter *adapter = netdev_priv(netdev); 291 struct fjes_hw *hw = &adapter->hw; 292 unsigned long flags; 293 int epidx; 294 295 netif_tx_stop_all_queues(netdev); 296 netif_carrier_off(netdev); 297 298 fjes_hw_raise_epstop(hw); 299 300 napi_disable(&adapter->napi); 301 302 spin_lock_irqsave(&hw->rx_status_lock, flags); 303 for (epidx = 0; epidx < hw->max_epid; epidx++) { 304 if (epidx == hw->my_epid) 305 continue; 306 307 if (fjes_hw_get_partner_ep_status(hw, epidx) == 308 EP_PARTNER_SHARED) 309 adapter->hw.ep_shm_info[epidx] 310 .tx.info->v1i.rx_status &= 311 ~FJES_RX_POLL_WORK; 312 } 313 spin_unlock_irqrestore(&hw->rx_status_lock, flags); 314 315 fjes_free_irq(adapter); 316 317 cancel_delayed_work_sync(&adapter->interrupt_watch_task); 318 cancel_work_sync(&adapter->unshare_watch_task); 319 adapter->unshare_watch_bitmask = 0; 320 cancel_work_sync(&adapter->raise_intr_rxdata_task); 321 cancel_work_sync(&adapter->tx_stall_task); 322 323 cancel_work_sync(&hw->update_zone_task); 324 cancel_work_sync(&hw->epstop_task); 325 326 fjes_hw_wait_epstop(hw); 327 328 fjes_free_resources(adapter); 329 330 return 0; 331 } 332 333 static int fjes_setup_resources(struct fjes_adapter *adapter) 334 { 335 struct net_device *netdev = adapter->netdev; 336 struct ep_share_mem_info *buf_pair; 337 struct fjes_hw *hw = &adapter->hw; 338 unsigned long flags; 339 int result; 340 int epidx; 341 342 mutex_lock(&hw->hw_info.lock); 343 result = fjes_hw_request_info(hw); 344 switch (result) { 345 case 0: 346 for (epidx = 0; epidx < hw->max_epid; epidx++) { 347 hw->ep_shm_info[epidx].es_status = 348 hw->hw_info.res_buf->info.info[epidx].es_status; 349 hw->ep_shm_info[epidx].zone = 350 hw->hw_info.res_buf->info.info[epidx].zone; 351 } 352 break; 353 default: 354 case -ENOMSG: 355 case -EBUSY: 356 adapter->force_reset = true; 357 358 mutex_unlock(&hw->hw_info.lock); 359 return result; 360 } 361 mutex_unlock(&hw->hw_info.lock); 362 363 for (epidx = 0; epidx < (hw->max_epid); epidx++) { 364 if ((epidx != hw->my_epid) && 365 (hw->ep_shm_info[epidx].es_status == 366 FJES_ZONING_STATUS_ENABLE)) { 367 fjes_hw_raise_interrupt(hw, epidx, 368 REG_ICTL_MASK_INFO_UPDATE); 369 hw->ep_shm_info[epidx].ep_stats 370 .send_intr_zoneupdate += 1; 371 } 372 } 373 374 msleep(FJES_OPEN_ZONE_UPDATE_WAIT * hw->max_epid); 375 376 for (epidx = 0; epidx < (hw->max_epid); epidx++) { 377 if (epidx == hw->my_epid) 378 continue; 379 380 buf_pair = &hw->ep_shm_info[epidx]; 381 382 spin_lock_irqsave(&hw->rx_status_lock, flags); 383 fjes_hw_setup_epbuf(&buf_pair->tx, netdev->dev_addr, 384 netdev->mtu); 385 spin_unlock_irqrestore(&hw->rx_status_lock, flags); 386 387 if (fjes_hw_epid_is_same_zone(hw, epidx)) { 388 mutex_lock(&hw->hw_info.lock); 389 result = 390 fjes_hw_register_buff_addr(hw, epidx, buf_pair); 391 mutex_unlock(&hw->hw_info.lock); 392 393 switch (result) { 394 case 0: 395 break; 396 case -ENOMSG: 397 case -EBUSY: 398 default: 399 adapter->force_reset = true; 400 return result; 401 } 402 403 hw->ep_shm_info[epidx].ep_stats 404 .com_regist_buf_exec += 1; 405 } 406 } 407 408 return 0; 409 } 410 411 static void fjes_free_resources(struct fjes_adapter *adapter) 412 { 413 struct net_device *netdev = adapter->netdev; 414 struct fjes_device_command_param param; 415 struct ep_share_mem_info *buf_pair; 416 struct fjes_hw *hw = &adapter->hw; 417 bool reset_flag = false; 418 unsigned long flags; 419 int result; 420 int epidx; 421 422 for (epidx = 0; epidx < hw->max_epid; epidx++) { 423 if (epidx == hw->my_epid) 424 continue; 425 426 mutex_lock(&hw->hw_info.lock); 427 result = fjes_hw_unregister_buff_addr(hw, epidx); 428 mutex_unlock(&hw->hw_info.lock); 429 430 hw->ep_shm_info[epidx].ep_stats.com_unregist_buf_exec += 1; 431 432 if (result) 433 reset_flag = true; 434 435 buf_pair = &hw->ep_shm_info[epidx]; 436 437 spin_lock_irqsave(&hw->rx_status_lock, flags); 438 fjes_hw_setup_epbuf(&buf_pair->tx, 439 netdev->dev_addr, netdev->mtu); 440 spin_unlock_irqrestore(&hw->rx_status_lock, flags); 441 442 clear_bit(epidx, &hw->txrx_stop_req_bit); 443 } 444 445 if (reset_flag || adapter->force_reset) { 446 result = fjes_hw_reset(hw); 447 448 adapter->force_reset = false; 449 450 if (result) 451 adapter->open_guard = true; 452 453 hw->hw_info.buffer_share_bit = 0; 454 455 memset((void *)¶m, 0, sizeof(param)); 456 457 param.req_len = hw->hw_info.req_buf_size; 458 param.req_start = __pa(hw->hw_info.req_buf); 459 param.res_len = hw->hw_info.res_buf_size; 460 param.res_start = __pa(hw->hw_info.res_buf); 461 param.share_start = __pa(hw->hw_info.share->ep_status); 462 463 fjes_hw_init_command_registers(hw, ¶m); 464 } 465 } 466 467 static void fjes_tx_stall_task(struct work_struct *work) 468 { 469 struct fjes_adapter *adapter = container_of(work, 470 struct fjes_adapter, tx_stall_task); 471 struct net_device *netdev = adapter->netdev; 472 struct fjes_hw *hw = &adapter->hw; 473 int all_queue_available, sendable; 474 enum ep_partner_status pstatus; 475 int max_epid, my_epid, epid; 476 union ep_buffer_info *info; 477 int i; 478 479 if (((long)jiffies - 480 dev_trans_start(netdev)) > FJES_TX_TX_STALL_TIMEOUT) { 481 netif_wake_queue(netdev); 482 return; 483 } 484 485 my_epid = hw->my_epid; 486 max_epid = hw->max_epid; 487 488 for (i = 0; i < 5; i++) { 489 all_queue_available = 1; 490 491 for (epid = 0; epid < max_epid; epid++) { 492 if (my_epid == epid) 493 continue; 494 495 pstatus = fjes_hw_get_partner_ep_status(hw, epid); 496 sendable = (pstatus == EP_PARTNER_SHARED); 497 if (!sendable) 498 continue; 499 500 info = adapter->hw.ep_shm_info[epid].tx.info; 501 502 if (!(info->v1i.rx_status & FJES_RX_MTU_CHANGING_DONE)) 503 return; 504 505 if (EP_RING_FULL(info->v1i.head, info->v1i.tail, 506 info->v1i.count_max)) { 507 all_queue_available = 0; 508 break; 509 } 510 } 511 512 if (all_queue_available) { 513 netif_wake_queue(netdev); 514 return; 515 } 516 } 517 518 usleep_range(50, 100); 519 520 queue_work(adapter->txrx_wq, &adapter->tx_stall_task); 521 } 522 523 static void fjes_force_close_task(struct work_struct *work) 524 { 525 struct fjes_adapter *adapter = container_of(work, 526 struct fjes_adapter, force_close_task); 527 struct net_device *netdev = adapter->netdev; 528 529 rtnl_lock(); 530 dev_close(netdev); 531 rtnl_unlock(); 532 } 533 534 static void fjes_raise_intr_rxdata_task(struct work_struct *work) 535 { 536 struct fjes_adapter *adapter = container_of(work, 537 struct fjes_adapter, raise_intr_rxdata_task); 538 struct fjes_hw *hw = &adapter->hw; 539 enum ep_partner_status pstatus; 540 int max_epid, my_epid, epid; 541 542 my_epid = hw->my_epid; 543 max_epid = hw->max_epid; 544 545 for (epid = 0; epid < max_epid; epid++) 546 hw->ep_shm_info[epid].tx_status_work = 0; 547 548 for (epid = 0; epid < max_epid; epid++) { 549 if (epid == my_epid) 550 continue; 551 552 pstatus = fjes_hw_get_partner_ep_status(hw, epid); 553 if (pstatus == EP_PARTNER_SHARED) { 554 hw->ep_shm_info[epid].tx_status_work = 555 hw->ep_shm_info[epid].tx.info->v1i.tx_status; 556 557 if (hw->ep_shm_info[epid].tx_status_work == 558 FJES_TX_DELAY_SEND_PENDING) { 559 hw->ep_shm_info[epid].tx.info->v1i.tx_status = 560 FJES_TX_DELAY_SEND_NONE; 561 } 562 } 563 } 564 565 for (epid = 0; epid < max_epid; epid++) { 566 if (epid == my_epid) 567 continue; 568 569 pstatus = fjes_hw_get_partner_ep_status(hw, epid); 570 if ((hw->ep_shm_info[epid].tx_status_work == 571 FJES_TX_DELAY_SEND_PENDING) && 572 (pstatus == EP_PARTNER_SHARED) && 573 !(hw->ep_shm_info[epid].rx.info->v1i.rx_status & 574 FJES_RX_POLL_WORK)) { 575 fjes_hw_raise_interrupt(hw, epid, 576 REG_ICTL_MASK_RX_DATA); 577 hw->ep_shm_info[epid].ep_stats.send_intr_rx += 1; 578 } 579 } 580 581 usleep_range(500, 1000); 582 } 583 584 static int fjes_tx_send(struct fjes_adapter *adapter, int dest, 585 void *data, size_t len) 586 { 587 int retval; 588 589 retval = fjes_hw_epbuf_tx_pkt_send(&adapter->hw.ep_shm_info[dest].tx, 590 data, len); 591 if (retval) 592 return retval; 593 594 adapter->hw.ep_shm_info[dest].tx.info->v1i.tx_status = 595 FJES_TX_DELAY_SEND_PENDING; 596 if (!work_pending(&adapter->raise_intr_rxdata_task)) 597 queue_work(adapter->txrx_wq, 598 &adapter->raise_intr_rxdata_task); 599 600 retval = 0; 601 return retval; 602 } 603 604 static netdev_tx_t 605 fjes_xmit_frame(struct sk_buff *skb, struct net_device *netdev) 606 { 607 struct fjes_adapter *adapter = netdev_priv(netdev); 608 struct fjes_hw *hw = &adapter->hw; 609 610 int max_epid, my_epid, dest_epid; 611 enum ep_partner_status pstatus; 612 struct netdev_queue *cur_queue; 613 char shortpkt[VLAN_ETH_HLEN]; 614 bool is_multi, vlan; 615 struct ethhdr *eth; 616 u16 queue_no = 0; 617 u16 vlan_id = 0; 618 netdev_tx_t ret; 619 char *data; 620 int len; 621 622 ret = NETDEV_TX_OK; 623 is_multi = false; 624 cur_queue = netdev_get_tx_queue(netdev, queue_no); 625 626 eth = (struct ethhdr *)skb->data; 627 my_epid = hw->my_epid; 628 629 vlan = (vlan_get_tag(skb, &vlan_id) == 0) ? true : false; 630 631 data = skb->data; 632 len = skb->len; 633 634 if (is_multicast_ether_addr(eth->h_dest)) { 635 dest_epid = 0; 636 max_epid = hw->max_epid; 637 is_multi = true; 638 } else if (is_local_ether_addr(eth->h_dest)) { 639 dest_epid = eth->h_dest[ETH_ALEN - 1]; 640 max_epid = dest_epid + 1; 641 642 if ((eth->h_dest[0] == 0x02) && 643 (0x00 == (eth->h_dest[1] | eth->h_dest[2] | 644 eth->h_dest[3] | eth->h_dest[4])) && 645 (dest_epid < hw->max_epid)) { 646 ; 647 } else { 648 dest_epid = 0; 649 max_epid = 0; 650 ret = NETDEV_TX_OK; 651 652 adapter->stats64.tx_packets += 1; 653 hw->ep_shm_info[my_epid].net_stats.tx_packets += 1; 654 adapter->stats64.tx_bytes += len; 655 hw->ep_shm_info[my_epid].net_stats.tx_bytes += len; 656 } 657 } else { 658 dest_epid = 0; 659 max_epid = 0; 660 ret = NETDEV_TX_OK; 661 662 adapter->stats64.tx_packets += 1; 663 hw->ep_shm_info[my_epid].net_stats.tx_packets += 1; 664 adapter->stats64.tx_bytes += len; 665 hw->ep_shm_info[my_epid].net_stats.tx_bytes += len; 666 } 667 668 for (; dest_epid < max_epid; dest_epid++) { 669 if (my_epid == dest_epid) 670 continue; 671 672 pstatus = fjes_hw_get_partner_ep_status(hw, dest_epid); 673 if (pstatus != EP_PARTNER_SHARED) { 674 if (!is_multi) 675 hw->ep_shm_info[dest_epid].ep_stats 676 .tx_dropped_not_shared += 1; 677 ret = NETDEV_TX_OK; 678 } else if (!fjes_hw_check_epbuf_version( 679 &adapter->hw.ep_shm_info[dest_epid].rx, 0)) { 680 /* version is NOT 0 */ 681 adapter->stats64.tx_carrier_errors += 1; 682 hw->ep_shm_info[dest_epid].net_stats 683 .tx_carrier_errors += 1; 684 hw->ep_shm_info[dest_epid].ep_stats 685 .tx_dropped_ver_mismatch += 1; 686 687 ret = NETDEV_TX_OK; 688 } else if (!fjes_hw_check_mtu( 689 &adapter->hw.ep_shm_info[dest_epid].rx, 690 netdev->mtu)) { 691 adapter->stats64.tx_dropped += 1; 692 hw->ep_shm_info[dest_epid].net_stats.tx_dropped += 1; 693 adapter->stats64.tx_errors += 1; 694 hw->ep_shm_info[dest_epid].net_stats.tx_errors += 1; 695 hw->ep_shm_info[dest_epid].ep_stats 696 .tx_dropped_buf_size_mismatch += 1; 697 698 ret = NETDEV_TX_OK; 699 } else if (vlan && 700 !fjes_hw_check_vlan_id( 701 &adapter->hw.ep_shm_info[dest_epid].rx, 702 vlan_id)) { 703 hw->ep_shm_info[dest_epid].ep_stats 704 .tx_dropped_vlanid_mismatch += 1; 705 ret = NETDEV_TX_OK; 706 } else { 707 if (len < VLAN_ETH_HLEN) { 708 memset(shortpkt, 0, VLAN_ETH_HLEN); 709 memcpy(shortpkt, skb->data, skb->len); 710 len = VLAN_ETH_HLEN; 711 data = shortpkt; 712 } 713 714 if (adapter->tx_retry_count == 0) { 715 adapter->tx_start_jiffies = jiffies; 716 adapter->tx_retry_count = 1; 717 } else { 718 adapter->tx_retry_count++; 719 } 720 721 if (fjes_tx_send(adapter, dest_epid, data, len)) { 722 if (is_multi) { 723 ret = NETDEV_TX_OK; 724 } else if ( 725 ((long)jiffies - 726 (long)adapter->tx_start_jiffies) >= 727 FJES_TX_RETRY_TIMEOUT) { 728 adapter->stats64.tx_fifo_errors += 1; 729 hw->ep_shm_info[dest_epid].net_stats 730 .tx_fifo_errors += 1; 731 adapter->stats64.tx_errors += 1; 732 hw->ep_shm_info[dest_epid].net_stats 733 .tx_errors += 1; 734 735 ret = NETDEV_TX_OK; 736 } else { 737 netif_trans_update(netdev); 738 hw->ep_shm_info[dest_epid].ep_stats 739 .tx_buffer_full += 1; 740 netif_tx_stop_queue(cur_queue); 741 742 if (!work_pending(&adapter->tx_stall_task)) 743 queue_work(adapter->txrx_wq, 744 &adapter->tx_stall_task); 745 746 ret = NETDEV_TX_BUSY; 747 } 748 } else { 749 if (!is_multi) { 750 adapter->stats64.tx_packets += 1; 751 hw->ep_shm_info[dest_epid].net_stats 752 .tx_packets += 1; 753 adapter->stats64.tx_bytes += len; 754 hw->ep_shm_info[dest_epid].net_stats 755 .tx_bytes += len; 756 } 757 758 adapter->tx_retry_count = 0; 759 ret = NETDEV_TX_OK; 760 } 761 } 762 } 763 764 if (ret == NETDEV_TX_OK) { 765 dev_kfree_skb(skb); 766 if (is_multi) { 767 adapter->stats64.tx_packets += 1; 768 hw->ep_shm_info[my_epid].net_stats.tx_packets += 1; 769 adapter->stats64.tx_bytes += 1; 770 hw->ep_shm_info[my_epid].net_stats.tx_bytes += len; 771 } 772 } 773 774 return ret; 775 } 776 777 static void fjes_tx_retry(struct net_device *netdev) 778 { 779 struct netdev_queue *queue = netdev_get_tx_queue(netdev, 0); 780 781 netif_tx_wake_queue(queue); 782 } 783 784 static void 785 fjes_get_stats64(struct net_device *netdev, struct rtnl_link_stats64 *stats) 786 { 787 struct fjes_adapter *adapter = netdev_priv(netdev); 788 789 memcpy(stats, &adapter->stats64, sizeof(struct rtnl_link_stats64)); 790 } 791 792 static int fjes_change_mtu(struct net_device *netdev, int new_mtu) 793 { 794 struct fjes_adapter *adapter = netdev_priv(netdev); 795 bool running = netif_running(netdev); 796 struct fjes_hw *hw = &adapter->hw; 797 unsigned long flags; 798 int ret = -EINVAL; 799 int idx, epidx; 800 801 for (idx = 0; fjes_support_mtu[idx] != 0; idx++) { 802 if (new_mtu <= fjes_support_mtu[idx]) { 803 new_mtu = fjes_support_mtu[idx]; 804 if (new_mtu == netdev->mtu) 805 return 0; 806 807 ret = 0; 808 break; 809 } 810 } 811 812 if (ret) 813 return ret; 814 815 if (running) { 816 spin_lock_irqsave(&hw->rx_status_lock, flags); 817 for (epidx = 0; epidx < hw->max_epid; epidx++) { 818 if (epidx == hw->my_epid) 819 continue; 820 hw->ep_shm_info[epidx].tx.info->v1i.rx_status &= 821 ~FJES_RX_MTU_CHANGING_DONE; 822 } 823 spin_unlock_irqrestore(&hw->rx_status_lock, flags); 824 825 netif_tx_stop_all_queues(netdev); 826 netif_carrier_off(netdev); 827 cancel_work_sync(&adapter->tx_stall_task); 828 napi_disable(&adapter->napi); 829 830 msleep(1000); 831 832 netif_tx_stop_all_queues(netdev); 833 } 834 835 netdev->mtu = new_mtu; 836 837 if (running) { 838 for (epidx = 0; epidx < hw->max_epid; epidx++) { 839 if (epidx == hw->my_epid) 840 continue; 841 842 spin_lock_irqsave(&hw->rx_status_lock, flags); 843 fjes_hw_setup_epbuf(&hw->ep_shm_info[epidx].tx, 844 netdev->dev_addr, 845 netdev->mtu); 846 847 hw->ep_shm_info[epidx].tx.info->v1i.rx_status |= 848 FJES_RX_MTU_CHANGING_DONE; 849 spin_unlock_irqrestore(&hw->rx_status_lock, flags); 850 } 851 852 netif_tx_wake_all_queues(netdev); 853 netif_carrier_on(netdev); 854 napi_enable(&adapter->napi); 855 napi_schedule(&adapter->napi); 856 } 857 858 return ret; 859 } 860 861 static int fjes_vlan_rx_add_vid(struct net_device *netdev, 862 __be16 proto, u16 vid) 863 { 864 struct fjes_adapter *adapter = netdev_priv(netdev); 865 bool ret = true; 866 int epid; 867 868 for (epid = 0; epid < adapter->hw.max_epid; epid++) { 869 if (epid == adapter->hw.my_epid) 870 continue; 871 872 if (!fjes_hw_check_vlan_id( 873 &adapter->hw.ep_shm_info[epid].tx, vid)) 874 ret = fjes_hw_set_vlan_id( 875 &adapter->hw.ep_shm_info[epid].tx, vid); 876 } 877 878 return ret ? 0 : -ENOSPC; 879 } 880 881 static int fjes_vlan_rx_kill_vid(struct net_device *netdev, 882 __be16 proto, u16 vid) 883 { 884 struct fjes_adapter *adapter = netdev_priv(netdev); 885 int epid; 886 887 for (epid = 0; epid < adapter->hw.max_epid; epid++) { 888 if (epid == adapter->hw.my_epid) 889 continue; 890 891 fjes_hw_del_vlan_id(&adapter->hw.ep_shm_info[epid].tx, vid); 892 } 893 894 return 0; 895 } 896 897 static void fjes_txrx_stop_req_irq(struct fjes_adapter *adapter, 898 int src_epid) 899 { 900 struct fjes_hw *hw = &adapter->hw; 901 enum ep_partner_status status; 902 unsigned long flags; 903 904 status = fjes_hw_get_partner_ep_status(hw, src_epid); 905 trace_fjes_txrx_stop_req_irq_pre(hw, src_epid, status); 906 switch (status) { 907 case EP_PARTNER_UNSHARE: 908 case EP_PARTNER_COMPLETE: 909 default: 910 break; 911 case EP_PARTNER_WAITING: 912 if (src_epid < hw->my_epid) { 913 spin_lock_irqsave(&hw->rx_status_lock, flags); 914 hw->ep_shm_info[src_epid].tx.info->v1i.rx_status |= 915 FJES_RX_STOP_REQ_DONE; 916 spin_unlock_irqrestore(&hw->rx_status_lock, flags); 917 918 clear_bit(src_epid, &hw->txrx_stop_req_bit); 919 set_bit(src_epid, &adapter->unshare_watch_bitmask); 920 921 if (!work_pending(&adapter->unshare_watch_task)) 922 queue_work(adapter->control_wq, 923 &adapter->unshare_watch_task); 924 } 925 break; 926 case EP_PARTNER_SHARED: 927 if (hw->ep_shm_info[src_epid].rx.info->v1i.rx_status & 928 FJES_RX_STOP_REQ_REQUEST) { 929 set_bit(src_epid, &hw->epstop_req_bit); 930 if (!work_pending(&hw->epstop_task)) 931 queue_work(adapter->control_wq, 932 &hw->epstop_task); 933 } 934 break; 935 } 936 trace_fjes_txrx_stop_req_irq_post(hw, src_epid); 937 } 938 939 static void fjes_stop_req_irq(struct fjes_adapter *adapter, int src_epid) 940 { 941 struct fjes_hw *hw = &adapter->hw; 942 enum ep_partner_status status; 943 unsigned long flags; 944 945 set_bit(src_epid, &hw->hw_info.buffer_unshare_reserve_bit); 946 947 status = fjes_hw_get_partner_ep_status(hw, src_epid); 948 trace_fjes_stop_req_irq_pre(hw, src_epid, status); 949 switch (status) { 950 case EP_PARTNER_WAITING: 951 spin_lock_irqsave(&hw->rx_status_lock, flags); 952 hw->ep_shm_info[src_epid].tx.info->v1i.rx_status |= 953 FJES_RX_STOP_REQ_DONE; 954 spin_unlock_irqrestore(&hw->rx_status_lock, flags); 955 clear_bit(src_epid, &hw->txrx_stop_req_bit); 956 /* fall through */ 957 case EP_PARTNER_UNSHARE: 958 case EP_PARTNER_COMPLETE: 959 default: 960 set_bit(src_epid, &adapter->unshare_watch_bitmask); 961 if (!work_pending(&adapter->unshare_watch_task)) 962 queue_work(adapter->control_wq, 963 &adapter->unshare_watch_task); 964 break; 965 case EP_PARTNER_SHARED: 966 set_bit(src_epid, &hw->epstop_req_bit); 967 968 if (!work_pending(&hw->epstop_task)) 969 queue_work(adapter->control_wq, &hw->epstop_task); 970 break; 971 } 972 trace_fjes_stop_req_irq_post(hw, src_epid); 973 } 974 975 static void fjes_update_zone_irq(struct fjes_adapter *adapter, 976 int src_epid) 977 { 978 struct fjes_hw *hw = &adapter->hw; 979 980 if (!work_pending(&hw->update_zone_task)) 981 queue_work(adapter->control_wq, &hw->update_zone_task); 982 } 983 984 static irqreturn_t fjes_intr(int irq, void *data) 985 { 986 struct fjes_adapter *adapter = data; 987 struct fjes_hw *hw = &adapter->hw; 988 irqreturn_t ret; 989 u32 icr; 990 991 icr = fjes_hw_capture_interrupt_status(hw); 992 993 if (icr & REG_IS_MASK_IS_ASSERT) { 994 if (icr & REG_ICTL_MASK_RX_DATA) { 995 fjes_rx_irq(adapter, icr & REG_IS_MASK_EPID); 996 hw->ep_shm_info[icr & REG_IS_MASK_EPID].ep_stats 997 .recv_intr_rx += 1; 998 } 999 1000 if (icr & REG_ICTL_MASK_DEV_STOP_REQ) { 1001 fjes_stop_req_irq(adapter, icr & REG_IS_MASK_EPID); 1002 hw->ep_shm_info[icr & REG_IS_MASK_EPID].ep_stats 1003 .recv_intr_stop += 1; 1004 } 1005 1006 if (icr & REG_ICTL_MASK_TXRX_STOP_REQ) { 1007 fjes_txrx_stop_req_irq(adapter, icr & REG_IS_MASK_EPID); 1008 hw->ep_shm_info[icr & REG_IS_MASK_EPID].ep_stats 1009 .recv_intr_unshare += 1; 1010 } 1011 1012 if (icr & REG_ICTL_MASK_TXRX_STOP_DONE) 1013 fjes_hw_set_irqmask(hw, 1014 REG_ICTL_MASK_TXRX_STOP_DONE, true); 1015 1016 if (icr & REG_ICTL_MASK_INFO_UPDATE) { 1017 fjes_update_zone_irq(adapter, icr & REG_IS_MASK_EPID); 1018 hw->ep_shm_info[icr & REG_IS_MASK_EPID].ep_stats 1019 .recv_intr_zoneupdate += 1; 1020 } 1021 1022 ret = IRQ_HANDLED; 1023 } else { 1024 ret = IRQ_NONE; 1025 } 1026 1027 return ret; 1028 } 1029 1030 static int fjes_rxframe_search_exist(struct fjes_adapter *adapter, 1031 int start_epid) 1032 { 1033 struct fjes_hw *hw = &adapter->hw; 1034 enum ep_partner_status pstatus; 1035 int max_epid, cur_epid; 1036 int i; 1037 1038 max_epid = hw->max_epid; 1039 start_epid = (start_epid + 1 + max_epid) % max_epid; 1040 1041 for (i = 0; i < max_epid; i++) { 1042 cur_epid = (start_epid + i) % max_epid; 1043 if (cur_epid == hw->my_epid) 1044 continue; 1045 1046 pstatus = fjes_hw_get_partner_ep_status(hw, cur_epid); 1047 if (pstatus == EP_PARTNER_SHARED) { 1048 if (!fjes_hw_epbuf_rx_is_empty( 1049 &hw->ep_shm_info[cur_epid].rx)) 1050 return cur_epid; 1051 } 1052 } 1053 return -1; 1054 } 1055 1056 static void *fjes_rxframe_get(struct fjes_adapter *adapter, size_t *psize, 1057 int *cur_epid) 1058 { 1059 void *frame; 1060 1061 *cur_epid = fjes_rxframe_search_exist(adapter, *cur_epid); 1062 if (*cur_epid < 0) 1063 return NULL; 1064 1065 frame = 1066 fjes_hw_epbuf_rx_curpkt_get_addr( 1067 &adapter->hw.ep_shm_info[*cur_epid].rx, psize); 1068 1069 return frame; 1070 } 1071 1072 static void fjes_rxframe_release(struct fjes_adapter *adapter, int cur_epid) 1073 { 1074 fjes_hw_epbuf_rx_curpkt_drop(&adapter->hw.ep_shm_info[cur_epid].rx); 1075 } 1076 1077 static void fjes_rx_irq(struct fjes_adapter *adapter, int src_epid) 1078 { 1079 struct fjes_hw *hw = &adapter->hw; 1080 1081 fjes_hw_set_irqmask(hw, REG_ICTL_MASK_RX_DATA, true); 1082 1083 adapter->unset_rx_last = true; 1084 napi_schedule(&adapter->napi); 1085 } 1086 1087 static int fjes_poll(struct napi_struct *napi, int budget) 1088 { 1089 struct fjes_adapter *adapter = 1090 container_of(napi, struct fjes_adapter, napi); 1091 struct net_device *netdev = napi->dev; 1092 struct fjes_hw *hw = &adapter->hw; 1093 struct sk_buff *skb; 1094 int work_done = 0; 1095 int cur_epid = 0; 1096 int epidx; 1097 size_t frame_len; 1098 void *frame; 1099 1100 spin_lock(&hw->rx_status_lock); 1101 for (epidx = 0; epidx < hw->max_epid; epidx++) { 1102 if (epidx == hw->my_epid) 1103 continue; 1104 1105 if (fjes_hw_get_partner_ep_status(hw, epidx) == 1106 EP_PARTNER_SHARED) 1107 adapter->hw.ep_shm_info[epidx] 1108 .tx.info->v1i.rx_status |= FJES_RX_POLL_WORK; 1109 } 1110 spin_unlock(&hw->rx_status_lock); 1111 1112 while (work_done < budget) { 1113 prefetch(&adapter->hw); 1114 frame = fjes_rxframe_get(adapter, &frame_len, &cur_epid); 1115 1116 if (frame) { 1117 skb = napi_alloc_skb(napi, frame_len); 1118 if (!skb) { 1119 adapter->stats64.rx_dropped += 1; 1120 hw->ep_shm_info[cur_epid].net_stats 1121 .rx_dropped += 1; 1122 adapter->stats64.rx_errors += 1; 1123 hw->ep_shm_info[cur_epid].net_stats 1124 .rx_errors += 1; 1125 } else { 1126 memcpy(skb_put(skb, frame_len), 1127 frame, frame_len); 1128 skb->protocol = eth_type_trans(skb, netdev); 1129 skb->ip_summed = CHECKSUM_UNNECESSARY; 1130 1131 netif_receive_skb(skb); 1132 1133 work_done++; 1134 1135 adapter->stats64.rx_packets += 1; 1136 hw->ep_shm_info[cur_epid].net_stats 1137 .rx_packets += 1; 1138 adapter->stats64.rx_bytes += frame_len; 1139 hw->ep_shm_info[cur_epid].net_stats 1140 .rx_bytes += frame_len; 1141 1142 if (is_multicast_ether_addr( 1143 ((struct ethhdr *)frame)->h_dest)) { 1144 adapter->stats64.multicast += 1; 1145 hw->ep_shm_info[cur_epid].net_stats 1146 .multicast += 1; 1147 } 1148 } 1149 1150 fjes_rxframe_release(adapter, cur_epid); 1151 adapter->unset_rx_last = true; 1152 } else { 1153 break; 1154 } 1155 } 1156 1157 if (work_done < budget) { 1158 napi_complete_done(napi, work_done); 1159 1160 if (adapter->unset_rx_last) { 1161 adapter->rx_last_jiffies = jiffies; 1162 adapter->unset_rx_last = false; 1163 } 1164 1165 if (((long)jiffies - (long)adapter->rx_last_jiffies) < 3) { 1166 napi_reschedule(napi); 1167 } else { 1168 spin_lock(&hw->rx_status_lock); 1169 for (epidx = 0; epidx < hw->max_epid; epidx++) { 1170 if (epidx == hw->my_epid) 1171 continue; 1172 if (fjes_hw_get_partner_ep_status(hw, epidx) == 1173 EP_PARTNER_SHARED) 1174 adapter->hw.ep_shm_info[epidx].tx 1175 .info->v1i.rx_status &= 1176 ~FJES_RX_POLL_WORK; 1177 } 1178 spin_unlock(&hw->rx_status_lock); 1179 1180 fjes_hw_set_irqmask(hw, REG_ICTL_MASK_RX_DATA, false); 1181 } 1182 } 1183 1184 return work_done; 1185 } 1186 1187 /* fjes_probe - Device Initialization Routine */ 1188 static int fjes_probe(struct platform_device *plat_dev) 1189 { 1190 struct fjes_adapter *adapter; 1191 struct net_device *netdev; 1192 struct resource *res; 1193 struct fjes_hw *hw; 1194 int err; 1195 1196 err = -ENOMEM; 1197 netdev = alloc_netdev_mq(sizeof(struct fjes_adapter), "es%d", 1198 NET_NAME_UNKNOWN, fjes_netdev_setup, 1199 FJES_MAX_QUEUES); 1200 1201 if (!netdev) 1202 goto err_out; 1203 1204 SET_NETDEV_DEV(netdev, &plat_dev->dev); 1205 1206 dev_set_drvdata(&plat_dev->dev, netdev); 1207 adapter = netdev_priv(netdev); 1208 adapter->netdev = netdev; 1209 adapter->plat_dev = plat_dev; 1210 hw = &adapter->hw; 1211 hw->back = adapter; 1212 1213 /* setup the private structure */ 1214 err = fjes_sw_init(adapter); 1215 if (err) 1216 goto err_free_netdev; 1217 1218 INIT_WORK(&adapter->force_close_task, fjes_force_close_task); 1219 adapter->force_reset = false; 1220 adapter->open_guard = false; 1221 1222 adapter->txrx_wq = alloc_workqueue(DRV_NAME "/txrx", WQ_MEM_RECLAIM, 0); 1223 adapter->control_wq = alloc_workqueue(DRV_NAME "/control", 1224 WQ_MEM_RECLAIM, 0); 1225 1226 INIT_WORK(&adapter->tx_stall_task, fjes_tx_stall_task); 1227 INIT_WORK(&adapter->raise_intr_rxdata_task, 1228 fjes_raise_intr_rxdata_task); 1229 INIT_WORK(&adapter->unshare_watch_task, fjes_watch_unshare_task); 1230 adapter->unshare_watch_bitmask = 0; 1231 1232 INIT_DELAYED_WORK(&adapter->interrupt_watch_task, fjes_irq_watch_task); 1233 adapter->interrupt_watch_enable = false; 1234 1235 res = platform_get_resource(plat_dev, IORESOURCE_MEM, 0); 1236 hw->hw_res.start = res->start; 1237 hw->hw_res.size = resource_size(res); 1238 hw->hw_res.irq = platform_get_irq(plat_dev, 0); 1239 err = fjes_hw_init(&adapter->hw); 1240 if (err) 1241 goto err_free_netdev; 1242 1243 /* setup MAC address (02:00:00:00:00:[epid])*/ 1244 netdev->dev_addr[0] = 2; 1245 netdev->dev_addr[1] = 0; 1246 netdev->dev_addr[2] = 0; 1247 netdev->dev_addr[3] = 0; 1248 netdev->dev_addr[4] = 0; 1249 netdev->dev_addr[5] = hw->my_epid; /* EPID */ 1250 1251 err = register_netdev(netdev); 1252 if (err) 1253 goto err_hw_exit; 1254 1255 netif_carrier_off(netdev); 1256 1257 fjes_dbg_adapter_init(adapter); 1258 1259 return 0; 1260 1261 err_hw_exit: 1262 fjes_hw_exit(&adapter->hw); 1263 err_free_netdev: 1264 free_netdev(netdev); 1265 err_out: 1266 return err; 1267 } 1268 1269 /* fjes_remove - Device Removal Routine */ 1270 static int fjes_remove(struct platform_device *plat_dev) 1271 { 1272 struct net_device *netdev = dev_get_drvdata(&plat_dev->dev); 1273 struct fjes_adapter *adapter = netdev_priv(netdev); 1274 struct fjes_hw *hw = &adapter->hw; 1275 1276 fjes_dbg_adapter_exit(adapter); 1277 1278 cancel_delayed_work_sync(&adapter->interrupt_watch_task); 1279 cancel_work_sync(&adapter->unshare_watch_task); 1280 cancel_work_sync(&adapter->raise_intr_rxdata_task); 1281 cancel_work_sync(&adapter->tx_stall_task); 1282 if (adapter->control_wq) 1283 destroy_workqueue(adapter->control_wq); 1284 if (adapter->txrx_wq) 1285 destroy_workqueue(adapter->txrx_wq); 1286 1287 unregister_netdev(netdev); 1288 1289 fjes_hw_exit(hw); 1290 1291 netif_napi_del(&adapter->napi); 1292 1293 free_netdev(netdev); 1294 1295 return 0; 1296 } 1297 1298 static int fjes_sw_init(struct fjes_adapter *adapter) 1299 { 1300 struct net_device *netdev = adapter->netdev; 1301 1302 netif_napi_add(netdev, &adapter->napi, fjes_poll, 64); 1303 1304 return 0; 1305 } 1306 1307 /* fjes_netdev_setup - netdevice initialization routine */ 1308 static void fjes_netdev_setup(struct net_device *netdev) 1309 { 1310 ether_setup(netdev); 1311 1312 netdev->watchdog_timeo = FJES_TX_RETRY_INTERVAL; 1313 netdev->netdev_ops = &fjes_netdev_ops; 1314 fjes_set_ethtool_ops(netdev); 1315 netdev->mtu = fjes_support_mtu[3]; 1316 netdev->min_mtu = fjes_support_mtu[0]; 1317 netdev->max_mtu = fjes_support_mtu[3]; 1318 netdev->flags |= IFF_BROADCAST; 1319 netdev->features |= NETIF_F_HW_CSUM | NETIF_F_HW_VLAN_CTAG_FILTER; 1320 } 1321 1322 static void fjes_irq_watch_task(struct work_struct *work) 1323 { 1324 struct fjes_adapter *adapter = container_of(to_delayed_work(work), 1325 struct fjes_adapter, interrupt_watch_task); 1326 1327 local_irq_disable(); 1328 fjes_intr(adapter->hw.hw_res.irq, adapter); 1329 local_irq_enable(); 1330 1331 if (fjes_rxframe_search_exist(adapter, 0) >= 0) 1332 napi_schedule(&adapter->napi); 1333 1334 if (adapter->interrupt_watch_enable) { 1335 if (!delayed_work_pending(&adapter->interrupt_watch_task)) 1336 queue_delayed_work(adapter->control_wq, 1337 &adapter->interrupt_watch_task, 1338 FJES_IRQ_WATCH_DELAY); 1339 } 1340 } 1341 1342 static void fjes_watch_unshare_task(struct work_struct *work) 1343 { 1344 struct fjes_adapter *adapter = 1345 container_of(work, struct fjes_adapter, unshare_watch_task); 1346 1347 struct net_device *netdev = adapter->netdev; 1348 struct fjes_hw *hw = &adapter->hw; 1349 1350 int unshare_watch, unshare_reserve; 1351 int max_epid, my_epid, epidx; 1352 int stop_req, stop_req_done; 1353 ulong unshare_watch_bitmask; 1354 unsigned long flags; 1355 int wait_time = 0; 1356 int is_shared; 1357 int ret; 1358 1359 my_epid = hw->my_epid; 1360 max_epid = hw->max_epid; 1361 1362 unshare_watch_bitmask = adapter->unshare_watch_bitmask; 1363 adapter->unshare_watch_bitmask = 0; 1364 1365 while ((unshare_watch_bitmask || hw->txrx_stop_req_bit) && 1366 (wait_time < 3000)) { 1367 for (epidx = 0; epidx < hw->max_epid; epidx++) { 1368 if (epidx == hw->my_epid) 1369 continue; 1370 1371 is_shared = fjes_hw_epid_is_shared(hw->hw_info.share, 1372 epidx); 1373 1374 stop_req = test_bit(epidx, &hw->txrx_stop_req_bit); 1375 1376 stop_req_done = hw->ep_shm_info[epidx].rx.info->v1i.rx_status & 1377 FJES_RX_STOP_REQ_DONE; 1378 1379 unshare_watch = test_bit(epidx, &unshare_watch_bitmask); 1380 1381 unshare_reserve = test_bit(epidx, 1382 &hw->hw_info.buffer_unshare_reserve_bit); 1383 1384 if ((!stop_req || 1385 (is_shared && (!is_shared || !stop_req_done))) && 1386 (is_shared || !unshare_watch || !unshare_reserve)) 1387 continue; 1388 1389 mutex_lock(&hw->hw_info.lock); 1390 ret = fjes_hw_unregister_buff_addr(hw, epidx); 1391 switch (ret) { 1392 case 0: 1393 break; 1394 case -ENOMSG: 1395 case -EBUSY: 1396 default: 1397 if (!work_pending( 1398 &adapter->force_close_task)) { 1399 adapter->force_reset = true; 1400 schedule_work( 1401 &adapter->force_close_task); 1402 } 1403 break; 1404 } 1405 mutex_unlock(&hw->hw_info.lock); 1406 hw->ep_shm_info[epidx].ep_stats 1407 .com_unregist_buf_exec += 1; 1408 1409 spin_lock_irqsave(&hw->rx_status_lock, flags); 1410 fjes_hw_setup_epbuf(&hw->ep_shm_info[epidx].tx, 1411 netdev->dev_addr, netdev->mtu); 1412 spin_unlock_irqrestore(&hw->rx_status_lock, flags); 1413 1414 clear_bit(epidx, &hw->txrx_stop_req_bit); 1415 clear_bit(epidx, &unshare_watch_bitmask); 1416 clear_bit(epidx, 1417 &hw->hw_info.buffer_unshare_reserve_bit); 1418 } 1419 1420 msleep(100); 1421 wait_time += 100; 1422 } 1423 1424 if (hw->hw_info.buffer_unshare_reserve_bit) { 1425 for (epidx = 0; epidx < hw->max_epid; epidx++) { 1426 if (epidx == hw->my_epid) 1427 continue; 1428 1429 if (test_bit(epidx, 1430 &hw->hw_info.buffer_unshare_reserve_bit)) { 1431 mutex_lock(&hw->hw_info.lock); 1432 1433 ret = fjes_hw_unregister_buff_addr(hw, epidx); 1434 switch (ret) { 1435 case 0: 1436 break; 1437 case -ENOMSG: 1438 case -EBUSY: 1439 default: 1440 if (!work_pending( 1441 &adapter->force_close_task)) { 1442 adapter->force_reset = true; 1443 schedule_work( 1444 &adapter->force_close_task); 1445 } 1446 break; 1447 } 1448 mutex_unlock(&hw->hw_info.lock); 1449 1450 hw->ep_shm_info[epidx].ep_stats 1451 .com_unregist_buf_exec += 1; 1452 1453 spin_lock_irqsave(&hw->rx_status_lock, flags); 1454 fjes_hw_setup_epbuf( 1455 &hw->ep_shm_info[epidx].tx, 1456 netdev->dev_addr, netdev->mtu); 1457 spin_unlock_irqrestore(&hw->rx_status_lock, 1458 flags); 1459 1460 clear_bit(epidx, &hw->txrx_stop_req_bit); 1461 clear_bit(epidx, &unshare_watch_bitmask); 1462 clear_bit(epidx, &hw->hw_info.buffer_unshare_reserve_bit); 1463 } 1464 1465 if (test_bit(epidx, &unshare_watch_bitmask)) { 1466 spin_lock_irqsave(&hw->rx_status_lock, flags); 1467 hw->ep_shm_info[epidx].tx.info->v1i.rx_status &= 1468 ~FJES_RX_STOP_REQ_DONE; 1469 spin_unlock_irqrestore(&hw->rx_status_lock, 1470 flags); 1471 } 1472 } 1473 } 1474 } 1475 1476 /* fjes_init_module - Driver Registration Routine */ 1477 static int __init fjes_init_module(void) 1478 { 1479 int result; 1480 1481 pr_info("%s - version %s - %s\n", 1482 fjes_driver_string, fjes_driver_version, fjes_copyright); 1483 1484 fjes_dbg_init(); 1485 1486 result = platform_driver_register(&fjes_driver); 1487 if (result < 0) { 1488 fjes_dbg_exit(); 1489 return result; 1490 } 1491 1492 result = acpi_bus_register_driver(&fjes_acpi_driver); 1493 if (result < 0) 1494 goto fail_acpi_driver; 1495 1496 return 0; 1497 1498 fail_acpi_driver: 1499 platform_driver_unregister(&fjes_driver); 1500 fjes_dbg_exit(); 1501 return result; 1502 } 1503 1504 module_init(fjes_init_module); 1505 1506 /* fjes_exit_module - Driver Exit Cleanup Routine */ 1507 static void __exit fjes_exit_module(void) 1508 { 1509 acpi_bus_unregister_driver(&fjes_acpi_driver); 1510 platform_driver_unregister(&fjes_driver); 1511 fjes_dbg_exit(); 1512 } 1513 1514 module_exit(fjes_exit_module); 1515