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