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