drivers/net/fjes/fjes_main.c

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