1 // SPDX-License-Identifier: GPL-2.0-only
3 * FUJITSU Extended Socket Network Device driver
4 * Copyright (c) 2015 FUJITSU LIMITED
7 #include <linux/module.h>
8 #include <linux/types.h>
10 #include <linux/platform_device.h>
11 #include <linux/netdevice.h>
12 #include <linux/interrupt.h>
15 #include "fjes_trace.h"
17 #define DRV_VERSION "1.2"
18 #define DRV_NAME "fjes"
19 char fjes_driver_name[] = DRV_NAME;
20 char fjes_driver_version[] = DRV_VERSION;
21 static const char fjes_driver_string[] =
22 "FUJITSU Extended Socket Network Device Driver";
23 static const char fjes_copyright[] =
24 "Copyright (c) 2015 FUJITSU LIMITED";
27 MODULE_DESCRIPTION("FUJITSU Extended Socket Network Device Driver");
28 MODULE_LICENSE("GPL");
29 MODULE_VERSION(DRV_VERSION);
31 #define ACPI_MOTHERBOARD_RESOURCE_HID "PNP0C02"
33 static const struct acpi_device_id fjes_acpi_ids[] = {
34 {ACPI_MOTHERBOARD_RESOURCE_HID, 0},
37 MODULE_DEVICE_TABLE(acpi, fjes_acpi_ids);
39 static bool is_extended_socket_device(struct acpi_device *device)
41 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL};
42 char str_buf[sizeof(FJES_ACPI_SYMBOL) + 1];
43 union acpi_object *str;
47 status = acpi_evaluate_object(device->handle, "_STR", NULL, &buffer);
48 if (ACPI_FAILURE(status))
52 result = utf16s_to_utf8s((wchar_t *)str->string.pointer,
53 str->string.length, UTF16_LITTLE_ENDIAN,
54 str_buf, sizeof(str_buf) - 1);
57 if (strncmp(FJES_ACPI_SYMBOL, str_buf, strlen(FJES_ACPI_SYMBOL)) != 0) {
58 kfree(buffer.pointer);
61 kfree(buffer.pointer);
66 static int acpi_check_extended_socket_status(struct acpi_device *device)
68 unsigned long long sta;
71 status = acpi_evaluate_integer(device->handle, "_STA", NULL, &sta);
72 if (ACPI_FAILURE(status))
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)))
85 fjes_get_acpi_resource(struct acpi_resource *acpi_res, void *data)
87 struct acpi_resource_address32 *addr;
88 struct acpi_resource_irq *irq;
89 struct resource *res = data;
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;
99 case ACPI_RESOURCE_TYPE_IRQ:
100 irq = &acpi_res->data.irq;
101 if (irq->interrupt_count != 1)
103 res[1].start = irq->interrupts[0];
104 res[1].end = irq->interrupts[0];
114 static struct resource fjes_resource[] = {
115 DEFINE_RES_MEM(0, 1),
119 static int fjes_acpi_add(struct acpi_device *device)
121 struct platform_device *plat_dev;
124 if (!is_extended_socket_device(device))
127 if (acpi_check_extended_socket_status(device))
130 status = acpi_walk_resources(device->handle, METHOD_NAME__CRS,
131 fjes_get_acpi_resource, fjes_resource);
132 if (ACPI_FAILURE(status))
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);
141 device->driver_data = plat_dev;
146 static void fjes_acpi_remove(struct acpi_device *device)
148 struct platform_device *plat_dev;
150 plat_dev = (struct platform_device *)acpi_driver_data(device);
151 platform_device_unregister(plat_dev);
154 static struct acpi_driver fjes_acpi_driver = {
157 .ids = fjes_acpi_ids,
159 .add = fjes_acpi_add,
160 .remove = fjes_acpi_remove,
164 static int fjes_setup_resources(struct fjes_adapter *adapter)
166 struct net_device *netdev = adapter->netdev;
167 struct ep_share_mem_info *buf_pair;
168 struct fjes_hw *hw = &adapter->hw;
173 mutex_lock(&hw->hw_info.lock);
174 result = fjes_hw_request_info(hw);
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;
187 adapter->force_reset = true;
189 mutex_unlock(&hw->hw_info.lock);
192 mutex_unlock(&hw->hw_info.lock);
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_stats
201 .send_intr_zoneupdate += 1;
205 msleep(FJES_OPEN_ZONE_UPDATE_WAIT * hw->max_epid);
207 for (epidx = 0; epidx < (hw->max_epid); epidx++) {
208 if (epidx == hw->my_epid)
211 buf_pair = &hw->ep_shm_info[epidx];
213 spin_lock_irqsave(&hw->rx_status_lock, flags);
214 fjes_hw_setup_epbuf(&buf_pair->tx, netdev->dev_addr,
216 spin_unlock_irqrestore(&hw->rx_status_lock, flags);
218 if (fjes_hw_epid_is_same_zone(hw, epidx)) {
219 mutex_lock(&hw->hw_info.lock);
221 fjes_hw_register_buff_addr(hw, epidx, buf_pair);
222 mutex_unlock(&hw->hw_info.lock);
230 adapter->force_reset = true;
234 hw->ep_shm_info[epidx].ep_stats
235 .com_regist_buf_exec += 1;
242 static void fjes_rx_irq(struct fjes_adapter *adapter, int src_epid)
244 struct fjes_hw *hw = &adapter->hw;
246 fjes_hw_set_irqmask(hw, REG_ICTL_MASK_RX_DATA, true);
248 adapter->unset_rx_last = true;
249 napi_schedule(&adapter->napi);
252 static void fjes_stop_req_irq(struct fjes_adapter *adapter, int src_epid)
254 struct fjes_hw *hw = &adapter->hw;
255 enum ep_partner_status status;
258 set_bit(src_epid, &hw->hw_info.buffer_unshare_reserve_bit);
260 status = fjes_hw_get_partner_ep_status(hw, src_epid);
261 trace_fjes_stop_req_irq_pre(hw, src_epid, 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);
270 case EP_PARTNER_UNSHARE:
271 case EP_PARTNER_COMPLETE:
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);
278 case EP_PARTNER_SHARED:
279 set_bit(src_epid, &hw->epstop_req_bit);
281 if (!work_pending(&hw->epstop_task))
282 queue_work(adapter->control_wq, &hw->epstop_task);
285 trace_fjes_stop_req_irq_post(hw, src_epid);
288 static void fjes_txrx_stop_req_irq(struct fjes_adapter *adapter,
291 struct fjes_hw *hw = &adapter->hw;
292 enum ep_partner_status status;
295 status = fjes_hw_get_partner_ep_status(hw, src_epid);
296 trace_fjes_txrx_stop_req_irq_pre(hw, src_epid, status);
298 case EP_PARTNER_UNSHARE:
299 case EP_PARTNER_COMPLETE:
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);
309 clear_bit(src_epid, &hw->txrx_stop_req_bit);
310 set_bit(src_epid, &adapter->unshare_watch_bitmask);
312 if (!work_pending(&adapter->unshare_watch_task))
313 queue_work(adapter->control_wq,
314 &adapter->unshare_watch_task);
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,
327 trace_fjes_txrx_stop_req_irq_post(hw, src_epid);
330 static void fjes_update_zone_irq(struct fjes_adapter *adapter,
333 struct fjes_hw *hw = &adapter->hw;
335 if (!work_pending(&hw->update_zone_task))
336 queue_work(adapter->control_wq, &hw->update_zone_task);
339 static irqreturn_t fjes_intr(int irq, void *data)
341 struct fjes_adapter *adapter = data;
342 struct fjes_hw *hw = &adapter->hw;
346 icr = fjes_hw_capture_interrupt_status(hw);
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_stats
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_stats
358 .recv_intr_stop += 1;
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_stats
364 .recv_intr_unshare += 1;
367 if (icr & REG_ICTL_MASK_TXRX_STOP_DONE)
368 fjes_hw_set_irqmask(hw,
369 REG_ICTL_MASK_TXRX_STOP_DONE, true);
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_stats
374 .recv_intr_zoneupdate += 1;
385 static int fjes_request_irq(struct fjes_adapter *adapter)
387 struct net_device *netdev = adapter->netdev;
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);
397 if (!adapter->irq_registered) {
398 result = request_irq(adapter->hw.hw_res.irq, fjes_intr,
399 IRQF_SHARED, netdev->name, adapter);
401 adapter->irq_registered = false;
403 adapter->irq_registered = true;
409 static void fjes_free_irq(struct fjes_adapter *adapter)
411 struct fjes_hw *hw = &adapter->hw;
413 adapter->interrupt_watch_enable = false;
414 cancel_delayed_work_sync(&adapter->interrupt_watch_task);
416 fjes_hw_set_irqmask(hw, REG_ICTL_MASK_ALL, true);
418 if (adapter->irq_registered) {
419 free_irq(adapter->hw.hw_res.irq, adapter);
420 adapter->irq_registered = false;
424 static void fjes_free_resources(struct fjes_adapter *adapter)
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;
435 for (epidx = 0; epidx < hw->max_epid; epidx++) {
436 if (epidx == hw->my_epid)
439 mutex_lock(&hw->hw_info.lock);
440 result = fjes_hw_unregister_buff_addr(hw, epidx);
441 mutex_unlock(&hw->hw_info.lock);
443 hw->ep_shm_info[epidx].ep_stats.com_unregist_buf_exec += 1;
448 buf_pair = &hw->ep_shm_info[epidx];
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);
455 clear_bit(epidx, &hw->txrx_stop_req_bit);
458 if (reset_flag || adapter->force_reset) {
459 result = fjes_hw_reset(hw);
461 adapter->force_reset = false;
464 adapter->open_guard = true;
466 hw->hw_info.buffer_share_bit = 0;
468 memset((void *)¶m, 0, sizeof(param));
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);
476 fjes_hw_init_command_registers(hw, ¶m);
480 /* fjes_open - Called when a network interface is made active */
481 static int fjes_open(struct net_device *netdev)
483 struct fjes_adapter *adapter = netdev_priv(netdev);
484 struct fjes_hw *hw = &adapter->hw;
487 if (adapter->open_guard)
490 result = fjes_setup_resources(adapter);
494 hw->txrx_stop_req_bit = 0;
495 hw->epstop_req_bit = 0;
497 napi_enable(&adapter->napi);
499 fjes_hw_capture_interrupt_status(hw);
501 result = fjes_request_irq(adapter);
505 fjes_hw_set_irqmask(hw, REG_ICTL_MASK_ALL, false);
507 netif_tx_start_all_queues(netdev);
508 netif_carrier_on(netdev);
513 fjes_free_irq(adapter);
514 napi_disable(&adapter->napi);
517 fjes_free_resources(adapter);
521 /* fjes_close - Disables a network interface */
522 static int fjes_close(struct net_device *netdev)
524 struct fjes_adapter *adapter = netdev_priv(netdev);
525 struct fjes_hw *hw = &adapter->hw;
529 netif_tx_stop_all_queues(netdev);
530 netif_carrier_off(netdev);
532 fjes_hw_raise_epstop(hw);
534 napi_disable(&adapter->napi);
536 spin_lock_irqsave(&hw->rx_status_lock, flags);
537 for (epidx = 0; epidx < hw->max_epid; epidx++) {
538 if (epidx == hw->my_epid)
541 if (fjes_hw_get_partner_ep_status(hw, epidx) ==
543 adapter->hw.ep_shm_info[epidx]
544 .tx.info->v1i.rx_status &=
547 spin_unlock_irqrestore(&hw->rx_status_lock, flags);
549 fjes_free_irq(adapter);
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);
557 cancel_work_sync(&hw->update_zone_task);
558 cancel_work_sync(&hw->epstop_task);
560 fjes_hw_wait_epstop(hw);
562 fjes_free_resources(adapter);
567 static int fjes_tx_send(struct fjes_adapter *adapter, int dest,
568 void *data, size_t len)
572 retval = fjes_hw_epbuf_tx_pkt_send(&adapter->hw.ep_shm_info[dest].tx,
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);
588 fjes_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
590 struct fjes_adapter *adapter = netdev_priv(netdev);
591 struct fjes_hw *hw = &adapter->hw;
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];
607 cur_queue = netdev_get_tx_queue(netdev, queue_no);
609 eth = (struct ethhdr *)skb->data;
610 my_epid = hw->my_epid;
612 vlan = (vlan_get_tag(skb, &vlan_id) == 0) ? true : false;
617 if (is_multicast_ether_addr(eth->h_dest)) {
619 max_epid = hw->max_epid;
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;
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)) {
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;
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;
651 for (; dest_epid < max_epid; dest_epid++) {
652 if (my_epid == dest_epid)
655 pstatus = fjes_hw_get_partner_ep_status(hw, dest_epid);
656 if (pstatus != EP_PARTNER_SHARED) {
658 hw->ep_shm_info[dest_epid].ep_stats
659 .tx_dropped_not_shared += 1;
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_stats
666 .tx_carrier_errors += 1;
667 hw->ep_shm_info[dest_epid].ep_stats
668 .tx_dropped_ver_mismatch += 1;
671 } else if (!fjes_hw_check_mtu(
672 &adapter->hw.ep_shm_info[dest_epid].rx,
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_stats
679 .tx_dropped_buf_size_mismatch += 1;
683 !fjes_hw_check_vlan_id(
684 &adapter->hw.ep_shm_info[dest_epid].rx,
686 hw->ep_shm_info[dest_epid].ep_stats
687 .tx_dropped_vlanid_mismatch += 1;
690 if (len < VLAN_ETH_HLEN) {
691 memset(shortpkt, 0, VLAN_ETH_HLEN);
692 memcpy(shortpkt, skb->data, skb->len);
697 if (adapter->tx_retry_count == 0) {
698 adapter->tx_start_jiffies = jiffies;
699 adapter->tx_retry_count = 1;
701 adapter->tx_retry_count++;
704 if (fjes_tx_send(adapter, dest_epid, data, len)) {
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_stats
713 .tx_fifo_errors += 1;
714 adapter->stats64.tx_errors += 1;
715 hw->ep_shm_info[dest_epid].net_stats
720 netif_trans_update(netdev);
721 hw->ep_shm_info[dest_epid].ep_stats
722 .tx_buffer_full += 1;
723 netif_tx_stop_queue(cur_queue);
725 if (!work_pending(&adapter->tx_stall_task))
726 queue_work(adapter->txrx_wq,
727 &adapter->tx_stall_task);
729 ret = NETDEV_TX_BUSY;
733 adapter->stats64.tx_packets += 1;
734 hw->ep_shm_info[dest_epid].net_stats
736 adapter->stats64.tx_bytes += len;
737 hw->ep_shm_info[dest_epid].net_stats
741 adapter->tx_retry_count = 0;
747 if (ret == NETDEV_TX_OK) {
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;
761 fjes_get_stats64(struct net_device *netdev, struct rtnl_link_stats64 *stats)
763 struct fjes_adapter *adapter = netdev_priv(netdev);
765 memcpy(stats, &adapter->stats64, sizeof(struct rtnl_link_stats64));
768 static int fjes_change_mtu(struct net_device *netdev, int new_mtu)
770 struct fjes_adapter *adapter = netdev_priv(netdev);
771 bool running = netif_running(netdev);
772 struct fjes_hw *hw = &adapter->hw;
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)
792 spin_lock_irqsave(&hw->rx_status_lock, flags);
793 for (epidx = 0; epidx < hw->max_epid; epidx++) {
794 if (epidx == hw->my_epid)
796 hw->ep_shm_info[epidx].tx.info->v1i.rx_status &=
797 ~FJES_RX_MTU_CHANGING_DONE;
799 spin_unlock_irqrestore(&hw->rx_status_lock, flags);
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);
808 netif_tx_stop_all_queues(netdev);
811 WRITE_ONCE(netdev->mtu, new_mtu);
814 for (epidx = 0; epidx < hw->max_epid; epidx++) {
815 if (epidx == hw->my_epid)
818 spin_lock_irqsave(&hw->rx_status_lock, flags);
819 fjes_hw_setup_epbuf(&hw->ep_shm_info[epidx].tx,
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);
828 netif_tx_wake_all_queues(netdev);
829 netif_carrier_on(netdev);
830 napi_enable(&adapter->napi);
831 napi_schedule(&adapter->napi);
837 static void fjes_tx_retry(struct net_device *netdev, unsigned int txqueue)
839 struct netdev_queue *queue = netdev_get_tx_queue(netdev, 0);
841 netif_tx_wake_queue(queue);
844 static int fjes_vlan_rx_add_vid(struct net_device *netdev,
845 __be16 proto, u16 vid)
847 struct fjes_adapter *adapter = netdev_priv(netdev);
851 for (epid = 0; epid < adapter->hw.max_epid; epid++) {
852 if (epid == adapter->hw.my_epid)
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);
861 return ret ? 0 : -ENOSPC;
864 static int fjes_vlan_rx_kill_vid(struct net_device *netdev,
865 __be16 proto, u16 vid)
867 struct fjes_adapter *adapter = netdev_priv(netdev);
870 for (epid = 0; epid < adapter->hw.max_epid; epid++) {
871 if (epid == adapter->hw.my_epid)
874 fjes_hw_del_vlan_id(&adapter->hw.ep_shm_info[epid].tx, vid);
880 static 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,
891 /* fjes_netdev_setup - netdevice initialization routine */
892 static void fjes_netdev_setup(struct net_device *netdev)
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;
905 static int fjes_rxframe_search_exist(struct fjes_adapter *adapter,
908 struct fjes_hw *hw = &adapter->hw;
909 enum ep_partner_status pstatus;
910 int max_epid, cur_epid;
913 max_epid = hw->max_epid;
914 start_epid = (start_epid + 1 + max_epid) % max_epid;
916 for (i = 0; i < max_epid; i++) {
917 cur_epid = (start_epid + i) % max_epid;
918 if (cur_epid == hw->my_epid)
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))
931 static void *fjes_rxframe_get(struct fjes_adapter *adapter, size_t *psize,
936 *cur_epid = fjes_rxframe_search_exist(adapter, *cur_epid);
941 fjes_hw_epbuf_rx_curpkt_get_addr(
942 &adapter->hw.ep_shm_info[*cur_epid].rx, psize);
947 static void fjes_rxframe_release(struct fjes_adapter *adapter, int cur_epid)
949 fjes_hw_epbuf_rx_curpkt_drop(&adapter->hw.ep_shm_info[cur_epid].rx);
952 static int fjes_poll(struct napi_struct *napi, int budget)
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;
965 spin_lock(&hw->rx_status_lock);
966 for (epidx = 0; epidx < hw->max_epid; epidx++) {
967 if (epidx == hw->my_epid)
970 if (fjes_hw_get_partner_ep_status(hw, epidx) ==
972 adapter->hw.ep_shm_info[epidx]
973 .tx.info->v1i.rx_status |= FJES_RX_POLL_WORK;
975 spin_unlock(&hw->rx_status_lock);
977 while (work_done < budget) {
978 prefetch(&adapter->hw);
979 frame = fjes_rxframe_get(adapter, &frame_len, &cur_epid);
982 skb = napi_alloc_skb(napi, frame_len);
984 adapter->stats64.rx_dropped += 1;
985 hw->ep_shm_info[cur_epid].net_stats
987 adapter->stats64.rx_errors += 1;
988 hw->ep_shm_info[cur_epid].net_stats
991 skb_put_data(skb, frame, frame_len);
992 skb->protocol = eth_type_trans(skb, netdev);
993 skb->ip_summed = CHECKSUM_UNNECESSARY;
995 netif_receive_skb(skb);
999 adapter->stats64.rx_packets += 1;
1000 hw->ep_shm_info[cur_epid].net_stats
1002 adapter->stats64.rx_bytes += frame_len;
1003 hw->ep_shm_info[cur_epid].net_stats
1004 .rx_bytes += frame_len;
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_stats
1014 fjes_rxframe_release(adapter, cur_epid);
1015 adapter->unset_rx_last = true;
1021 if (work_done < budget) {
1022 napi_complete_done(napi, work_done);
1024 if (adapter->unset_rx_last) {
1025 adapter->rx_last_jiffies = jiffies;
1026 adapter->unset_rx_last = false;
1029 if (((long)jiffies - (long)adapter->rx_last_jiffies) < 3) {
1030 napi_schedule(napi);
1032 spin_lock(&hw->rx_status_lock);
1033 for (epidx = 0; epidx < hw->max_epid; epidx++) {
1034 if (epidx == hw->my_epid)
1036 if (fjes_hw_get_partner_ep_status(hw, epidx) ==
1038 adapter->hw.ep_shm_info[epidx].tx
1039 .info->v1i.rx_status &=
1042 spin_unlock(&hw->rx_status_lock);
1044 fjes_hw_set_irqmask(hw, REG_ICTL_MASK_RX_DATA, false);
1051 static int fjes_sw_init(struct fjes_adapter *adapter)
1053 struct net_device *netdev = adapter->netdev;
1055 netif_napi_add(netdev, &adapter->napi, fjes_poll);
1060 static void fjes_force_close_task(struct work_struct *work)
1062 struct fjes_adapter *adapter = container_of(work,
1063 struct fjes_adapter, force_close_task);
1064 struct net_device *netdev = adapter->netdev;
1071 static void fjes_tx_stall_task(struct work_struct *work)
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;
1083 if (((long)jiffies -
1084 dev_trans_start(netdev)) > FJES_TX_TX_STALL_TIMEOUT) {
1085 netif_wake_queue(netdev);
1089 my_epid = hw->my_epid;
1090 max_epid = hw->max_epid;
1092 for (i = 0; i < 5; i++) {
1093 all_queue_available = 1;
1095 for (epid = 0; epid < max_epid; epid++) {
1096 if (my_epid == epid)
1099 pstatus = fjes_hw_get_partner_ep_status(hw, epid);
1100 sendable = (pstatus == EP_PARTNER_SHARED);
1104 info = adapter->hw.ep_shm_info[epid].tx.info;
1106 if (!(info->v1i.rx_status & FJES_RX_MTU_CHANGING_DONE))
1109 if (EP_RING_FULL(info->v1i.head, info->v1i.tail,
1110 info->v1i.count_max)) {
1111 all_queue_available = 0;
1116 if (all_queue_available) {
1117 netif_wake_queue(netdev);
1122 usleep_range(50, 100);
1124 queue_work(adapter->txrx_wq, &adapter->tx_stall_task);
1127 static void fjes_raise_intr_rxdata_task(struct work_struct *work)
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;
1135 my_epid = hw->my_epid;
1136 max_epid = hw->max_epid;
1138 for (epid = 0; epid < max_epid; epid++)
1139 hw->ep_shm_info[epid].tx_status_work = 0;
1141 for (epid = 0; epid < max_epid; epid++) {
1142 if (epid == my_epid)
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;
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;
1158 for (epid = 0; epid < max_epid; epid++) {
1159 if (epid == my_epid)
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;
1174 usleep_range(500, 1000);
1177 static void fjes_watch_unshare_task(struct work_struct *work)
1179 struct fjes_adapter *adapter =
1180 container_of(work, struct fjes_adapter, unshare_watch_task);
1182 struct net_device *netdev = adapter->netdev;
1183 struct fjes_hw *hw = &adapter->hw;
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;
1194 my_epid = hw->my_epid;
1195 max_epid = hw->max_epid;
1197 unshare_watch_bitmask = adapter->unshare_watch_bitmask;
1198 adapter->unshare_watch_bitmask = 0;
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)
1206 is_shared = fjes_hw_epid_is_shared(hw->hw_info.share,
1209 stop_req = test_bit(epidx, &hw->txrx_stop_req_bit);
1211 stop_req_done = hw->ep_shm_info[epidx].rx.info->v1i.rx_status &
1212 FJES_RX_STOP_REQ_DONE;
1214 unshare_watch = test_bit(epidx, &unshare_watch_bitmask);
1216 unshare_reserve = test_bit(epidx,
1217 &hw->hw_info.buffer_unshare_reserve_bit);
1220 (is_shared && (!is_shared || !stop_req_done))) &&
1221 (is_shared || !unshare_watch || !unshare_reserve))
1224 mutex_lock(&hw->hw_info.lock);
1225 ret = fjes_hw_unregister_buff_addr(hw, epidx);
1233 &adapter->force_close_task)) {
1234 adapter->force_reset = true;
1236 &adapter->force_close_task);
1240 mutex_unlock(&hw->hw_info.lock);
1241 hw->ep_shm_info[epidx].ep_stats
1242 .com_unregist_buf_exec += 1;
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);
1249 clear_bit(epidx, &hw->txrx_stop_req_bit);
1250 clear_bit(epidx, &unshare_watch_bitmask);
1252 &hw->hw_info.buffer_unshare_reserve_bit);
1259 if (hw->hw_info.buffer_unshare_reserve_bit) {
1260 for (epidx = 0; epidx < max_epid; epidx++) {
1261 if (epidx == my_epid)
1265 &hw->hw_info.buffer_unshare_reserve_bit)) {
1266 mutex_lock(&hw->hw_info.lock);
1268 ret = fjes_hw_unregister_buff_addr(hw, epidx);
1276 &adapter->force_close_task)) {
1277 adapter->force_reset = true;
1279 &adapter->force_close_task);
1283 mutex_unlock(&hw->hw_info.lock);
1285 hw->ep_shm_info[epidx].ep_stats
1286 .com_unregist_buf_exec += 1;
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,
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);
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,
1311 static void fjes_irq_watch_task(struct work_struct *work)
1313 struct fjes_adapter *adapter = container_of(to_delayed_work(work),
1314 struct fjes_adapter, interrupt_watch_task);
1316 local_irq_disable();
1317 fjes_intr(adapter->hw.hw_res.irq, adapter);
1320 if (fjes_rxframe_search_exist(adapter, 0) >= 0)
1321 napi_schedule(&adapter->napi);
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);
1331 /* fjes_probe - Device Initialization Routine */
1332 static int fjes_probe(struct platform_device *plat_dev)
1334 struct fjes_adapter *adapter;
1335 struct net_device *netdev;
1336 struct resource *res;
1342 netdev = alloc_netdev_mq(sizeof(struct fjes_adapter), "es%d",
1343 NET_NAME_UNKNOWN, fjes_netdev_setup,
1349 SET_NETDEV_DEV(netdev, &plat_dev->dev);
1351 dev_set_drvdata(&plat_dev->dev, netdev);
1352 adapter = netdev_priv(netdev);
1353 adapter->netdev = netdev;
1354 adapter->plat_dev = plat_dev;
1358 /* setup the private structure */
1359 err = fjes_sw_init(adapter);
1361 goto err_free_netdev;
1363 INIT_WORK(&adapter->force_close_task, fjes_force_close_task);
1364 adapter->force_reset = false;
1365 adapter->open_guard = false;
1367 adapter->txrx_wq = alloc_workqueue(DRV_NAME "/txrx", WQ_MEM_RECLAIM, 0);
1368 if (unlikely(!adapter->txrx_wq)) {
1370 goto err_free_netdev;
1373 adapter->control_wq = alloc_workqueue(DRV_NAME "/control",
1375 if (unlikely(!adapter->control_wq)) {
1377 goto err_free_txrx_wq;
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;
1386 INIT_DELAYED_WORK(&adapter->interrupt_watch_task, fjes_irq_watch_task);
1387 adapter->interrupt_watch_enable = false;
1389 res = platform_get_resource(plat_dev, IORESOURCE_MEM, 0);
1392 goto err_free_control_wq;
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;
1402 err = fjes_hw_init(&adapter->hw);
1404 goto err_free_control_wq;
1406 /* setup MAC address (02:00:00:00:00:[epid])*/
1412 addr[5] = hw->my_epid; /* EPID */
1413 eth_hw_addr_set(netdev, addr);
1415 err = register_netdev(netdev);
1419 netif_carrier_off(netdev);
1421 fjes_dbg_adapter_init(adapter);
1426 fjes_hw_exit(&adapter->hw);
1427 err_free_control_wq:
1428 destroy_workqueue(adapter->control_wq);
1430 destroy_workqueue(adapter->txrx_wq);
1432 free_netdev(netdev);
1437 /* fjes_remove - Device Removal Routine */
1438 static void fjes_remove(struct platform_device *plat_dev)
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;
1444 fjes_dbg_adapter_exit(adapter);
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);
1455 unregister_netdev(netdev);
1459 netif_napi_del(&adapter->napi);
1461 free_netdev(netdev);
1464 static struct platform_driver fjes_driver = {
1468 .probe = fjes_probe,
1469 .remove = fjes_remove,
1473 acpi_find_extended_socket_device(acpi_handle obj_handle, u32 level,
1474 void *context, void **return_value)
1476 struct acpi_device *device;
1477 bool *found = context;
1479 device = acpi_fetch_acpi_dev(obj_handle);
1483 if (strcmp(acpi_device_hid(device), ACPI_MOTHERBOARD_RESOURCE_HID))
1486 if (!is_extended_socket_device(device))
1489 if (acpi_check_extended_socket_status(device))
1493 return AE_CTRL_TERMINATE;
1496 /* fjes_init_module - Driver Registration Routine */
1497 static int __init fjes_init_module(void)
1502 acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX,
1503 acpi_find_extended_socket_device, NULL, &found,
1509 pr_info("%s - version %s - %s\n",
1510 fjes_driver_string, fjes_driver_version, fjes_copyright);
1514 result = platform_driver_register(&fjes_driver);
1520 result = acpi_bus_register_driver(&fjes_acpi_driver);
1522 goto fail_acpi_driver;
1527 platform_driver_unregister(&fjes_driver);
1532 module_init(fjes_init_module);
1534 /* fjes_exit_module - Driver Exit Cleanup Routine */
1535 static void __exit fjes_exit_module(void)
1537 acpi_bus_unregister_driver(&fjes_acpi_driver);
1538 platform_driver_unregister(&fjes_driver);
1542 module_exit(fjes_exit_module);