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 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";
25
26 MODULE_AUTHOR("Taku Izumi <izumi.taku@jp.fujitsu.com>");
27 MODULE_DESCRIPTION("FUJITSU Extended Socket Network Device Driver");
28 MODULE_LICENSE("GPL");
29 MODULE_VERSION(DRV_VERSION);
30
31 #define ACPI_MOTHERBOARD_RESOURCE_HID "PNP0C02"
32
33 static const struct acpi_device_id fjes_acpi_ids[] = {
34 {ACPI_MOTHERBOARD_RESOURCE_HID, 0},
35 {"", 0},
36 };
37 MODULE_DEVICE_TABLE(acpi, fjes_acpi_ids);
38
is_extended_socket_device(struct acpi_device * device)39 static 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
acpi_check_extended_socket_status(struct acpi_device * device)66 static 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
84 static acpi_status
fjes_get_acpi_resource(struct acpi_resource * acpi_res,void * data)85 fjes_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
114 static struct resource fjes_resource[] = {
115 DEFINE_RES_MEM(0, 1),
116 DEFINE_RES_IRQ(0)
117 };
118
fjes_acpi_add(struct acpi_device * device)119 static 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
fjes_acpi_remove(struct acpi_device * device)146 static 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
154 static 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
fjes_setup_resources(struct fjes_adapter * adapter)164 static 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_stats
201 .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_stats
235 .com_regist_buf_exec += 1;
236 }
237 }
238
239 return 0;
240 }
241
fjes_rx_irq(struct fjes_adapter * adapter,int src_epid)242 static 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
fjes_stop_req_irq(struct fjes_adapter * adapter,int src_epid)252 static 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
fjes_txrx_stop_req_irq(struct fjes_adapter * adapter,int src_epid)288 static 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
fjes_update_zone_irq(struct fjes_adapter * adapter,int src_epid)330 static 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
fjes_intr(int irq,void * data)339 static 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_stats
352 .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_stats
358 .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_stats
364 .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_stats
374 .recv_intr_zoneupdate += 1;
375 }
376
377 ret = IRQ_HANDLED;
378 } else {
379 ret = IRQ_NONE;
380 }
381
382 return ret;
383 }
384
fjes_request_irq(struct fjes_adapter * adapter)385 static 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 else
403 adapter->irq_registered = true;
404 }
405
406 return result;
407 }
408
fjes_free_irq(struct fjes_adapter * adapter)409 static 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
fjes_free_resources(struct fjes_adapter * adapter)424 static 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 */
fjes_open(struct net_device * netdev)481 static 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
512 err_req_irq:
513 fjes_free_irq(adapter);
514 napi_disable(&adapter->napi);
515
516 err_setup_res:
517 fjes_free_resources(adapter);
518 return result;
519 }
520
521 /* fjes_close - Disables a network interface */
fjes_close(struct net_device * netdev)522 static 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
fjes_tx_send(struct fjes_adapter * adapter,int dest,void * data,size_t len)567 static 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
587 static netdev_tx_t
fjes_xmit_frame(struct sk_buff * skb,struct net_device * netdev)588 fjes_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_stats
659 .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_stats
666 .tx_carrier_errors += 1;
667 hw->ep_shm_info[dest_epid].ep_stats
668 .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_stats
679 .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_stats
687 .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_stats
713 .tx_fifo_errors += 1;
714 adapter->stats64.tx_errors += 1;
715 hw->ep_shm_info[dest_epid].net_stats
716 .tx_errors += 1;
717
718 ret = NETDEV_TX_OK;
719 } else {
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);
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_stats
735 .tx_packets += 1;
736 adapter->stats64.tx_bytes += len;
737 hw->ep_shm_info[dest_epid].net_stats
738 .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
760 static void
fjes_get_stats64(struct net_device * netdev,struct rtnl_link_stats64 * stats)761 fjes_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
fjes_change_mtu(struct net_device * netdev,int new_mtu)768 static 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
fjes_tx_retry(struct net_device * netdev,unsigned int txqueue)837 static 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
fjes_vlan_rx_add_vid(struct net_device * netdev,__be16 proto,u16 vid)844 static 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
fjes_vlan_rx_kill_vid(struct net_device * netdev,__be16 proto,u16 vid)864 static 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
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,
889 };
890
891 /* fjes_netdev_setup - netdevice initialization routine */
fjes_netdev_setup(struct net_device * netdev)892 static 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
fjes_rxframe_search_exist(struct fjes_adapter * adapter,int start_epid)905 static 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
fjes_rxframe_get(struct fjes_adapter * adapter,size_t * psize,int * cur_epid)931 static 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
fjes_rxframe_release(struct fjes_adapter * adapter,int cur_epid)947 static 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
fjes_poll(struct napi_struct * napi,int budget)952 static 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_stats
986 .rx_dropped += 1;
987 adapter->stats64.rx_errors += 1;
988 hw->ep_shm_info[cur_epid].net_stats
989 .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_stats
1001 .rx_packets += 1;
1002 adapter->stats64.rx_bytes += frame_len;
1003 hw->ep_shm_info[cur_epid].net_stats
1004 .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_stats
1010 .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].tx
1039 .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
fjes_sw_init(struct fjes_adapter * adapter)1051 static 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
fjes_force_close_task(struct work_struct * work)1060 static 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
fjes_tx_stall_task(struct work_struct * work)1071 static 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
fjes_raise_intr_rxdata_task(struct work_struct * work)1127 static 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
fjes_watch_unshare_task(struct work_struct * work)1177 static 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_stats
1242 .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_stats
1286 .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
fjes_irq_watch_task(struct work_struct * work)1311 static 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 */
fjes_probe(struct platform_device * plat_dev)1332 static 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
1425 err_hw_exit:
1426 fjes_hw_exit(&adapter->hw);
1427 err_free_control_wq:
1428 destroy_workqueue(adapter->control_wq);
1429 err_free_txrx_wq:
1430 destroy_workqueue(adapter->txrx_wq);
1431 err_free_netdev:
1432 free_netdev(netdev);
1433 err_out:
1434 return err;
1435 }
1436
1437 /* fjes_remove - Device Removal Routine */
fjes_remove(struct platform_device * plat_dev)1438 static 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
1464 static struct platform_driver fjes_driver = {
1465 .driver = {
1466 .name = DRV_NAME,
1467 },
1468 .probe = fjes_probe,
1469 .remove = fjes_remove,
1470 };
1471
1472 static acpi_status
acpi_find_extended_socket_device(acpi_handle obj_handle,u32 level,void * context,void ** return_value)1473 acpi_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 */
fjes_init_module(void)1497 static 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
1526 fail_acpi_driver:
1527 platform_driver_unregister(&fjes_driver);
1528 fjes_dbg_exit();
1529 return result;
1530 }
1531
1532 module_init(fjes_init_module);
1533
1534 /* fjes_exit_module - Driver Exit Cleanup Routine */
fjes_exit_module(void)1535 static 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
1542 module_exit(fjes_exit_module);
1543