drivers/net/fjes/fjes_main.c

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