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