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