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