drivers/net/fjes/fjes_main.c

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