2 * FUJITSU Extended Socket Network Device driver
3 * Copyright (c) 2015 FUJITSU LIMITED
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.
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
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/>.
17 * The full GNU General Public License is included in this distribution in
18 * the file called "COPYING".
22 #include <linux/module.h>
23 #include <linux/types.h>
24 #include <linux/nls.h>
25 #include <linux/platform_device.h>
26 #include <linux/netdevice.h>
27 #include <linux/interrupt.h>
30 #include "fjes_trace.h"
34 #define DRV_VERSION __stringify(MAJ) "." __stringify(MIN)
35 #define DRV_NAME "fjes"
36 char fjes_driver_name
[] = DRV_NAME
;
37 char fjes_driver_version
[] = DRV_VERSION
;
38 static const char fjes_driver_string
[] =
39 "FUJITSU Extended Socket Network Device Driver";
40 static const char fjes_copyright
[] =
41 "Copyright (c) 2015 FUJITSU LIMITED";
43 MODULE_AUTHOR("Taku Izumi <izumi.taku@jp.fujitsu.com>");
44 MODULE_DESCRIPTION("FUJITSU Extended Socket Network Device Driver");
45 MODULE_LICENSE("GPL");
46 MODULE_VERSION(DRV_VERSION
);
48 static int fjes_request_irq(struct fjes_adapter
*);
49 static void fjes_free_irq(struct fjes_adapter
*);
51 static int fjes_open(struct net_device
*);
52 static int fjes_close(struct net_device
*);
53 static int fjes_setup_resources(struct fjes_adapter
*);
54 static void fjes_free_resources(struct fjes_adapter
*);
55 static netdev_tx_t
fjes_xmit_frame(struct sk_buff
*, struct net_device
*);
56 static void fjes_raise_intr_rxdata_task(struct work_struct
*);
57 static void fjes_tx_stall_task(struct work_struct
*);
58 static void fjes_force_close_task(struct work_struct
*);
59 static irqreturn_t
fjes_intr(int, void*);
60 static struct rtnl_link_stats64
*
61 fjes_get_stats64(struct net_device
*, struct rtnl_link_stats64
*);
62 static int fjes_change_mtu(struct net_device
*, int);
63 static int fjes_vlan_rx_add_vid(struct net_device
*, __be16 proto
, u16
);
64 static int fjes_vlan_rx_kill_vid(struct net_device
*, __be16 proto
, u16
);
65 static void fjes_tx_retry(struct net_device
*);
67 static int fjes_acpi_add(struct acpi_device
*);
68 static int fjes_acpi_remove(struct acpi_device
*);
69 static acpi_status
fjes_get_acpi_resource(struct acpi_resource
*, void*);
71 static int fjes_probe(struct platform_device
*);
72 static int fjes_remove(struct platform_device
*);
74 static int fjes_sw_init(struct fjes_adapter
*);
75 static void fjes_netdev_setup(struct net_device
*);
76 static void fjes_irq_watch_task(struct work_struct
*);
77 static void fjes_watch_unshare_task(struct work_struct
*);
78 static void fjes_rx_irq(struct fjes_adapter
*, int);
79 static int fjes_poll(struct napi_struct
*, int);
81 static const struct acpi_device_id fjes_acpi_ids
[] = {
85 MODULE_DEVICE_TABLE(acpi
, fjes_acpi_ids
);
87 static struct acpi_driver fjes_acpi_driver
= {
94 .remove
= fjes_acpi_remove
,
98 static struct platform_driver fjes_driver
= {
103 .remove
= fjes_remove
,
106 static struct resource fjes_resource
[] = {
108 .flags
= IORESOURCE_MEM
,
113 .flags
= IORESOURCE_IRQ
,
119 static int fjes_acpi_add(struct acpi_device
*device
)
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
;
128 status
= acpi_evaluate_object(device
->handle
, "_STR", NULL
, &buffer
);
129 if (ACPI_FAILURE(status
))
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);
138 if (strncmp(FJES_ACPI_SYMBOL
, str_buf
, strlen(FJES_ACPI_SYMBOL
)) != 0) {
139 kfree(buffer
.pointer
);
142 kfree(buffer
.pointer
);
144 status
= acpi_walk_resources(device
->handle
, METHOD_NAME__CRS
,
145 fjes_get_acpi_resource
, fjes_resource
);
146 if (ACPI_FAILURE(status
))
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
;
157 static int fjes_acpi_remove(struct acpi_device
*device
)
159 struct platform_device
*plat_dev
;
161 plat_dev
= (struct platform_device
*)acpi_driver_data(device
);
162 platform_device_unregister(plat_dev
);
168 fjes_get_acpi_resource(struct acpi_resource
*acpi_res
, void *data
)
170 struct acpi_resource_address32
*addr
;
171 struct acpi_resource_irq
*irq
;
172 struct resource
*res
= data
;
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;
182 case ACPI_RESOURCE_TYPE_IRQ
:
183 irq
= &acpi_res
->data
.irq
;
184 if (irq
->interrupt_count
!= 1)
186 res
[1].start
= irq
->interrupts
[0];
187 res
[1].end
= irq
->interrupts
[0];
197 static int fjes_request_irq(struct fjes_adapter
*adapter
)
199 struct net_device
*netdev
= adapter
->netdev
;
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
);
209 if (!adapter
->irq_registered
) {
210 result
= request_irq(adapter
->hw
.hw_res
.irq
, fjes_intr
,
211 IRQF_SHARED
, netdev
->name
, adapter
);
213 adapter
->irq_registered
= false;
215 adapter
->irq_registered
= true;
221 static void fjes_free_irq(struct fjes_adapter
*adapter
)
223 struct fjes_hw
*hw
= &adapter
->hw
;
225 adapter
->interrupt_watch_enable
= false;
226 cancel_delayed_work_sync(&adapter
->interrupt_watch_task
);
228 fjes_hw_set_irqmask(hw
, REG_ICTL_MASK_ALL
, true);
230 if (adapter
->irq_registered
) {
231 free_irq(adapter
->hw
.hw_res
.irq
, adapter
);
232 adapter
->irq_registered
= false;
236 static const struct net_device_ops fjes_netdev_ops
= {
237 .ndo_open
= fjes_open
,
238 .ndo_stop
= fjes_close
,
239 .ndo_start_xmit
= fjes_xmit_frame
,
240 .ndo_get_stats64
= fjes_get_stats64
,
241 .ndo_change_mtu
= fjes_change_mtu
,
242 .ndo_tx_timeout
= fjes_tx_retry
,
243 .ndo_vlan_rx_add_vid
= fjes_vlan_rx_add_vid
,
244 .ndo_vlan_rx_kill_vid
= fjes_vlan_rx_kill_vid
,
247 /* fjes_open - Called when a network interface is made active */
248 static int fjes_open(struct net_device
*netdev
)
250 struct fjes_adapter
*adapter
= netdev_priv(netdev
);
251 struct fjes_hw
*hw
= &adapter
->hw
;
254 if (adapter
->open_guard
)
257 result
= fjes_setup_resources(adapter
);
261 hw
->txrx_stop_req_bit
= 0;
262 hw
->epstop_req_bit
= 0;
264 napi_enable(&adapter
->napi
);
266 fjes_hw_capture_interrupt_status(hw
);
268 result
= fjes_request_irq(adapter
);
272 fjes_hw_set_irqmask(hw
, REG_ICTL_MASK_ALL
, false);
274 netif_tx_start_all_queues(netdev
);
275 netif_carrier_on(netdev
);
280 fjes_free_irq(adapter
);
281 napi_disable(&adapter
->napi
);
284 fjes_free_resources(adapter
);
288 /* fjes_close - Disables a network interface */
289 static int fjes_close(struct net_device
*netdev
)
291 struct fjes_adapter
*adapter
= netdev_priv(netdev
);
292 struct fjes_hw
*hw
= &adapter
->hw
;
296 netif_tx_stop_all_queues(netdev
);
297 netif_carrier_off(netdev
);
299 fjes_hw_raise_epstop(hw
);
301 napi_disable(&adapter
->napi
);
303 spin_lock_irqsave(&hw
->rx_status_lock
, flags
);
304 for (epidx
= 0; epidx
< hw
->max_epid
; epidx
++) {
305 if (epidx
== hw
->my_epid
)
308 if (fjes_hw_get_partner_ep_status(hw
, epidx
) ==
310 adapter
->hw
.ep_shm_info
[epidx
]
311 .tx
.info
->v1i
.rx_status
&=
314 spin_unlock_irqrestore(&hw
->rx_status_lock
, flags
);
316 fjes_free_irq(adapter
);
318 cancel_delayed_work_sync(&adapter
->interrupt_watch_task
);
319 cancel_work_sync(&adapter
->unshare_watch_task
);
320 adapter
->unshare_watch_bitmask
= 0;
321 cancel_work_sync(&adapter
->raise_intr_rxdata_task
);
322 cancel_work_sync(&adapter
->tx_stall_task
);
324 cancel_work_sync(&hw
->update_zone_task
);
325 cancel_work_sync(&hw
->epstop_task
);
327 fjes_hw_wait_epstop(hw
);
329 fjes_free_resources(adapter
);
334 static int fjes_setup_resources(struct fjes_adapter
*adapter
)
336 struct net_device
*netdev
= adapter
->netdev
;
337 struct ep_share_mem_info
*buf_pair
;
338 struct fjes_hw
*hw
= &adapter
->hw
;
343 mutex_lock(&hw
->hw_info
.lock
);
344 result
= fjes_hw_request_info(hw
);
347 for (epidx
= 0; epidx
< hw
->max_epid
; epidx
++) {
348 hw
->ep_shm_info
[epidx
].es_status
=
349 hw
->hw_info
.res_buf
->info
.info
[epidx
].es_status
;
350 hw
->ep_shm_info
[epidx
].zone
=
351 hw
->hw_info
.res_buf
->info
.info
[epidx
].zone
;
357 adapter
->force_reset
= true;
359 mutex_unlock(&hw
->hw_info
.lock
);
362 mutex_unlock(&hw
->hw_info
.lock
);
364 for (epidx
= 0; epidx
< (hw
->max_epid
); epidx
++) {
365 if ((epidx
!= hw
->my_epid
) &&
366 (hw
->ep_shm_info
[epidx
].es_status
==
367 FJES_ZONING_STATUS_ENABLE
)) {
368 fjes_hw_raise_interrupt(hw
, epidx
,
369 REG_ICTL_MASK_INFO_UPDATE
);
370 hw
->ep_shm_info
[epidx
].ep_stats
371 .send_intr_zoneupdate
+= 1;
375 msleep(FJES_OPEN_ZONE_UPDATE_WAIT
* hw
->max_epid
);
377 for (epidx
= 0; epidx
< (hw
->max_epid
); epidx
++) {
378 if (epidx
== hw
->my_epid
)
381 buf_pair
= &hw
->ep_shm_info
[epidx
];
383 spin_lock_irqsave(&hw
->rx_status_lock
, flags
);
384 fjes_hw_setup_epbuf(&buf_pair
->tx
, netdev
->dev_addr
,
386 spin_unlock_irqrestore(&hw
->rx_status_lock
, flags
);
388 if (fjes_hw_epid_is_same_zone(hw
, epidx
)) {
389 mutex_lock(&hw
->hw_info
.lock
);
391 fjes_hw_register_buff_addr(hw
, epidx
, buf_pair
);
392 mutex_unlock(&hw
->hw_info
.lock
);
400 adapter
->force_reset
= true;
404 hw
->ep_shm_info
[epidx
].ep_stats
405 .com_regist_buf_exec
+= 1;
412 static void fjes_free_resources(struct fjes_adapter
*adapter
)
414 struct net_device
*netdev
= adapter
->netdev
;
415 struct fjes_device_command_param param
;
416 struct ep_share_mem_info
*buf_pair
;
417 struct fjes_hw
*hw
= &adapter
->hw
;
418 bool reset_flag
= false;
423 for (epidx
= 0; epidx
< hw
->max_epid
; epidx
++) {
424 if (epidx
== hw
->my_epid
)
427 mutex_lock(&hw
->hw_info
.lock
);
428 result
= fjes_hw_unregister_buff_addr(hw
, epidx
);
429 mutex_unlock(&hw
->hw_info
.lock
);
431 hw
->ep_shm_info
[epidx
].ep_stats
.com_unregist_buf_exec
+= 1;
436 buf_pair
= &hw
->ep_shm_info
[epidx
];
438 spin_lock_irqsave(&hw
->rx_status_lock
, flags
);
439 fjes_hw_setup_epbuf(&buf_pair
->tx
,
440 netdev
->dev_addr
, netdev
->mtu
);
441 spin_unlock_irqrestore(&hw
->rx_status_lock
, flags
);
443 clear_bit(epidx
, &hw
->txrx_stop_req_bit
);
446 if (reset_flag
|| adapter
->force_reset
) {
447 result
= fjes_hw_reset(hw
);
449 adapter
->force_reset
= false;
452 adapter
->open_guard
= true;
454 hw
->hw_info
.buffer_share_bit
= 0;
456 memset((void *)¶m
, 0, sizeof(param
));
458 param
.req_len
= hw
->hw_info
.req_buf_size
;
459 param
.req_start
= __pa(hw
->hw_info
.req_buf
);
460 param
.res_len
= hw
->hw_info
.res_buf_size
;
461 param
.res_start
= __pa(hw
->hw_info
.res_buf
);
462 param
.share_start
= __pa(hw
->hw_info
.share
->ep_status
);
464 fjes_hw_init_command_registers(hw
, ¶m
);
468 static void fjes_tx_stall_task(struct work_struct
*work
)
470 struct fjes_adapter
*adapter
= container_of(work
,
471 struct fjes_adapter
, tx_stall_task
);
472 struct net_device
*netdev
= adapter
->netdev
;
473 struct fjes_hw
*hw
= &adapter
->hw
;
474 int all_queue_available
, sendable
;
475 enum ep_partner_status pstatus
;
476 int max_epid
, my_epid
, epid
;
477 union ep_buffer_info
*info
;
481 dev_trans_start(netdev
)) > FJES_TX_TX_STALL_TIMEOUT
) {
482 netif_wake_queue(netdev
);
486 my_epid
= hw
->my_epid
;
487 max_epid
= hw
->max_epid
;
489 for (i
= 0; i
< 5; i
++) {
490 all_queue_available
= 1;
492 for (epid
= 0; epid
< max_epid
; epid
++) {
496 pstatus
= fjes_hw_get_partner_ep_status(hw
, epid
);
497 sendable
= (pstatus
== EP_PARTNER_SHARED
);
501 info
= adapter
->hw
.ep_shm_info
[epid
].tx
.info
;
503 if (!(info
->v1i
.rx_status
& FJES_RX_MTU_CHANGING_DONE
))
506 if (EP_RING_FULL(info
->v1i
.head
, info
->v1i
.tail
,
507 info
->v1i
.count_max
)) {
508 all_queue_available
= 0;
513 if (all_queue_available
) {
514 netif_wake_queue(netdev
);
519 usleep_range(50, 100);
521 queue_work(adapter
->txrx_wq
, &adapter
->tx_stall_task
);
524 static void fjes_force_close_task(struct work_struct
*work
)
526 struct fjes_adapter
*adapter
= container_of(work
,
527 struct fjes_adapter
, force_close_task
);
528 struct net_device
*netdev
= adapter
->netdev
;
535 static void fjes_raise_intr_rxdata_task(struct work_struct
*work
)
537 struct fjes_adapter
*adapter
= container_of(work
,
538 struct fjes_adapter
, raise_intr_rxdata_task
);
539 struct fjes_hw
*hw
= &adapter
->hw
;
540 enum ep_partner_status pstatus
;
541 int max_epid
, my_epid
, epid
;
543 my_epid
= hw
->my_epid
;
544 max_epid
= hw
->max_epid
;
546 for (epid
= 0; epid
< max_epid
; epid
++)
547 hw
->ep_shm_info
[epid
].tx_status_work
= 0;
549 for (epid
= 0; epid
< max_epid
; epid
++) {
553 pstatus
= fjes_hw_get_partner_ep_status(hw
, epid
);
554 if (pstatus
== EP_PARTNER_SHARED
) {
555 hw
->ep_shm_info
[epid
].tx_status_work
=
556 hw
->ep_shm_info
[epid
].tx
.info
->v1i
.tx_status
;
558 if (hw
->ep_shm_info
[epid
].tx_status_work
==
559 FJES_TX_DELAY_SEND_PENDING
) {
560 hw
->ep_shm_info
[epid
].tx
.info
->v1i
.tx_status
=
561 FJES_TX_DELAY_SEND_NONE
;
566 for (epid
= 0; epid
< max_epid
; epid
++) {
570 pstatus
= fjes_hw_get_partner_ep_status(hw
, epid
);
571 if ((hw
->ep_shm_info
[epid
].tx_status_work
==
572 FJES_TX_DELAY_SEND_PENDING
) &&
573 (pstatus
== EP_PARTNER_SHARED
) &&
574 !(hw
->ep_shm_info
[epid
].rx
.info
->v1i
.rx_status
&
575 FJES_RX_POLL_WORK
)) {
576 fjes_hw_raise_interrupt(hw
, epid
,
577 REG_ICTL_MASK_RX_DATA
);
578 hw
->ep_shm_info
[epid
].ep_stats
.send_intr_rx
+= 1;
582 usleep_range(500, 1000);
585 static int fjes_tx_send(struct fjes_adapter
*adapter
, int dest
,
586 void *data
, size_t len
)
590 retval
= fjes_hw_epbuf_tx_pkt_send(&adapter
->hw
.ep_shm_info
[dest
].tx
,
595 adapter
->hw
.ep_shm_info
[dest
].tx
.info
->v1i
.tx_status
=
596 FJES_TX_DELAY_SEND_PENDING
;
597 if (!work_pending(&adapter
->raise_intr_rxdata_task
))
598 queue_work(adapter
->txrx_wq
,
599 &adapter
->raise_intr_rxdata_task
);
606 fjes_xmit_frame(struct sk_buff
*skb
, struct net_device
*netdev
)
608 struct fjes_adapter
*adapter
= netdev_priv(netdev
);
609 struct fjes_hw
*hw
= &adapter
->hw
;
611 int max_epid
, my_epid
, dest_epid
;
612 enum ep_partner_status pstatus
;
613 struct netdev_queue
*cur_queue
;
614 char shortpkt
[VLAN_ETH_HLEN
];
625 cur_queue
= netdev_get_tx_queue(netdev
, queue_no
);
627 eth
= (struct ethhdr
*)skb
->data
;
628 my_epid
= hw
->my_epid
;
630 vlan
= (vlan_get_tag(skb
, &vlan_id
) == 0) ? true : false;
635 if (is_multicast_ether_addr(eth
->h_dest
)) {
637 max_epid
= hw
->max_epid
;
639 } else if (is_local_ether_addr(eth
->h_dest
)) {
640 dest_epid
= eth
->h_dest
[ETH_ALEN
- 1];
641 max_epid
= dest_epid
+ 1;
643 if ((eth
->h_dest
[0] == 0x02) &&
644 (0x00 == (eth
->h_dest
[1] | eth
->h_dest
[2] |
645 eth
->h_dest
[3] | eth
->h_dest
[4])) &&
646 (dest_epid
< hw
->max_epid
)) {
653 adapter
->stats64
.tx_packets
+= 1;
654 hw
->ep_shm_info
[my_epid
].net_stats
.tx_packets
+= 1;
655 adapter
->stats64
.tx_bytes
+= len
;
656 hw
->ep_shm_info
[my_epid
].net_stats
.tx_bytes
+= len
;
663 adapter
->stats64
.tx_packets
+= 1;
664 hw
->ep_shm_info
[my_epid
].net_stats
.tx_packets
+= 1;
665 adapter
->stats64
.tx_bytes
+= len
;
666 hw
->ep_shm_info
[my_epid
].net_stats
.tx_bytes
+= len
;
669 for (; dest_epid
< max_epid
; dest_epid
++) {
670 if (my_epid
== dest_epid
)
673 pstatus
= fjes_hw_get_partner_ep_status(hw
, dest_epid
);
674 if (pstatus
!= EP_PARTNER_SHARED
) {
676 hw
->ep_shm_info
[dest_epid
].ep_stats
677 .tx_dropped_not_shared
+= 1;
679 } else if (!fjes_hw_check_epbuf_version(
680 &adapter
->hw
.ep_shm_info
[dest_epid
].rx
, 0)) {
681 /* version is NOT 0 */
682 adapter
->stats64
.tx_carrier_errors
+= 1;
683 hw
->ep_shm_info
[dest_epid
].net_stats
684 .tx_carrier_errors
+= 1;
685 hw
->ep_shm_info
[dest_epid
].ep_stats
686 .tx_dropped_ver_mismatch
+= 1;
689 } else if (!fjes_hw_check_mtu(
690 &adapter
->hw
.ep_shm_info
[dest_epid
].rx
,
692 adapter
->stats64
.tx_dropped
+= 1;
693 hw
->ep_shm_info
[dest_epid
].net_stats
.tx_dropped
+= 1;
694 adapter
->stats64
.tx_errors
+= 1;
695 hw
->ep_shm_info
[dest_epid
].net_stats
.tx_errors
+= 1;
696 hw
->ep_shm_info
[dest_epid
].ep_stats
697 .tx_dropped_buf_size_mismatch
+= 1;
701 !fjes_hw_check_vlan_id(
702 &adapter
->hw
.ep_shm_info
[dest_epid
].rx
,
704 hw
->ep_shm_info
[dest_epid
].ep_stats
705 .tx_dropped_vlanid_mismatch
+= 1;
708 if (len
< VLAN_ETH_HLEN
) {
709 memset(shortpkt
, 0, VLAN_ETH_HLEN
);
710 memcpy(shortpkt
, skb
->data
, skb
->len
);
715 if (adapter
->tx_retry_count
== 0) {
716 adapter
->tx_start_jiffies
= jiffies
;
717 adapter
->tx_retry_count
= 1;
719 adapter
->tx_retry_count
++;
722 if (fjes_tx_send(adapter
, dest_epid
, data
, len
)) {
727 (long)adapter
->tx_start_jiffies
) >=
728 FJES_TX_RETRY_TIMEOUT
) {
729 adapter
->stats64
.tx_fifo_errors
+= 1;
730 hw
->ep_shm_info
[dest_epid
].net_stats
731 .tx_fifo_errors
+= 1;
732 adapter
->stats64
.tx_errors
+= 1;
733 hw
->ep_shm_info
[dest_epid
].net_stats
738 netif_trans_update(netdev
);
739 hw
->ep_shm_info
[dest_epid
].ep_stats
740 .tx_buffer_full
+= 1;
741 netif_tx_stop_queue(cur_queue
);
743 if (!work_pending(&adapter
->tx_stall_task
))
744 queue_work(adapter
->txrx_wq
,
745 &adapter
->tx_stall_task
);
747 ret
= NETDEV_TX_BUSY
;
751 adapter
->stats64
.tx_packets
+= 1;
752 hw
->ep_shm_info
[dest_epid
].net_stats
754 adapter
->stats64
.tx_bytes
+= len
;
755 hw
->ep_shm_info
[dest_epid
].net_stats
759 adapter
->tx_retry_count
= 0;
765 if (ret
== NETDEV_TX_OK
) {
768 adapter
->stats64
.tx_packets
+= 1;
769 hw
->ep_shm_info
[my_epid
].net_stats
.tx_packets
+= 1;
770 adapter
->stats64
.tx_bytes
+= 1;
771 hw
->ep_shm_info
[my_epid
].net_stats
.tx_bytes
+= len
;
778 static void fjes_tx_retry(struct net_device
*netdev
)
780 struct netdev_queue
*queue
= netdev_get_tx_queue(netdev
, 0);
782 netif_tx_wake_queue(queue
);
785 static struct rtnl_link_stats64
*
786 fjes_get_stats64(struct net_device
*netdev
, struct rtnl_link_stats64
*stats
)
788 struct fjes_adapter
*adapter
= netdev_priv(netdev
);
790 memcpy(stats
, &adapter
->stats64
, sizeof(struct rtnl_link_stats64
));
795 static int fjes_change_mtu(struct net_device
*netdev
, int new_mtu
)
797 struct fjes_adapter
*adapter
= netdev_priv(netdev
);
798 bool running
= netif_running(netdev
);
799 struct fjes_hw
*hw
= &adapter
->hw
;
804 for (idx
= 0; fjes_support_mtu
[idx
] != 0; idx
++) {
805 if (new_mtu
<= fjes_support_mtu
[idx
]) {
806 new_mtu
= fjes_support_mtu
[idx
];
807 if (new_mtu
== netdev
->mtu
)
819 spin_lock_irqsave(&hw
->rx_status_lock
, flags
);
820 for (epidx
= 0; epidx
< hw
->max_epid
; epidx
++) {
821 if (epidx
== hw
->my_epid
)
823 hw
->ep_shm_info
[epidx
].tx
.info
->v1i
.rx_status
&=
824 ~FJES_RX_MTU_CHANGING_DONE
;
826 spin_unlock_irqrestore(&hw
->rx_status_lock
, flags
);
828 netif_tx_stop_all_queues(netdev
);
829 netif_carrier_off(netdev
);
830 cancel_work_sync(&adapter
->tx_stall_task
);
831 napi_disable(&adapter
->napi
);
835 netif_tx_stop_all_queues(netdev
);
838 netdev
->mtu
= new_mtu
;
841 for (epidx
= 0; epidx
< hw
->max_epid
; epidx
++) {
842 if (epidx
== hw
->my_epid
)
845 spin_lock_irqsave(&hw
->rx_status_lock
, flags
);
846 fjes_hw_setup_epbuf(&hw
->ep_shm_info
[epidx
].tx
,
850 hw
->ep_shm_info
[epidx
].tx
.info
->v1i
.rx_status
|=
851 FJES_RX_MTU_CHANGING_DONE
;
852 spin_unlock_irqrestore(&hw
->rx_status_lock
, flags
);
855 netif_tx_wake_all_queues(netdev
);
856 netif_carrier_on(netdev
);
857 napi_enable(&adapter
->napi
);
858 napi_schedule(&adapter
->napi
);
864 static int fjes_vlan_rx_add_vid(struct net_device
*netdev
,
865 __be16 proto
, u16 vid
)
867 struct fjes_adapter
*adapter
= netdev_priv(netdev
);
871 for (epid
= 0; epid
< adapter
->hw
.max_epid
; epid
++) {
872 if (epid
== adapter
->hw
.my_epid
)
875 if (!fjes_hw_check_vlan_id(
876 &adapter
->hw
.ep_shm_info
[epid
].tx
, vid
))
877 ret
= fjes_hw_set_vlan_id(
878 &adapter
->hw
.ep_shm_info
[epid
].tx
, vid
);
881 return ret
? 0 : -ENOSPC
;
884 static int fjes_vlan_rx_kill_vid(struct net_device
*netdev
,
885 __be16 proto
, u16 vid
)
887 struct fjes_adapter
*adapter
= netdev_priv(netdev
);
890 for (epid
= 0; epid
< adapter
->hw
.max_epid
; epid
++) {
891 if (epid
== adapter
->hw
.my_epid
)
894 fjes_hw_del_vlan_id(&adapter
->hw
.ep_shm_info
[epid
].tx
, vid
);
900 static void fjes_txrx_stop_req_irq(struct fjes_adapter
*adapter
,
903 struct fjes_hw
*hw
= &adapter
->hw
;
904 enum ep_partner_status status
;
907 status
= fjes_hw_get_partner_ep_status(hw
, src_epid
);
908 trace_fjes_txrx_stop_req_irq_pre(hw
, src_epid
, status
);
910 case EP_PARTNER_UNSHARE
:
911 case EP_PARTNER_COMPLETE
:
914 case EP_PARTNER_WAITING
:
915 if (src_epid
< hw
->my_epid
) {
916 spin_lock_irqsave(&hw
->rx_status_lock
, flags
);
917 hw
->ep_shm_info
[src_epid
].tx
.info
->v1i
.rx_status
|=
918 FJES_RX_STOP_REQ_DONE
;
919 spin_unlock_irqrestore(&hw
->rx_status_lock
, flags
);
921 clear_bit(src_epid
, &hw
->txrx_stop_req_bit
);
922 set_bit(src_epid
, &adapter
->unshare_watch_bitmask
);
924 if (!work_pending(&adapter
->unshare_watch_task
))
925 queue_work(adapter
->control_wq
,
926 &adapter
->unshare_watch_task
);
929 case EP_PARTNER_SHARED
:
930 if (hw
->ep_shm_info
[src_epid
].rx
.info
->v1i
.rx_status
&
931 FJES_RX_STOP_REQ_REQUEST
) {
932 set_bit(src_epid
, &hw
->epstop_req_bit
);
933 if (!work_pending(&hw
->epstop_task
))
934 queue_work(adapter
->control_wq
,
939 trace_fjes_txrx_stop_req_irq_post(hw
, src_epid
);
942 static void fjes_stop_req_irq(struct fjes_adapter
*adapter
, int src_epid
)
944 struct fjes_hw
*hw
= &adapter
->hw
;
945 enum ep_partner_status status
;
948 set_bit(src_epid
, &hw
->hw_info
.buffer_unshare_reserve_bit
);
950 status
= fjes_hw_get_partner_ep_status(hw
, src_epid
);
951 trace_fjes_stop_req_irq_pre(hw
, src_epid
, status
);
953 case EP_PARTNER_WAITING
:
954 spin_lock_irqsave(&hw
->rx_status_lock
, flags
);
955 hw
->ep_shm_info
[src_epid
].tx
.info
->v1i
.rx_status
|=
956 FJES_RX_STOP_REQ_DONE
;
957 spin_unlock_irqrestore(&hw
->rx_status_lock
, flags
);
958 clear_bit(src_epid
, &hw
->txrx_stop_req_bit
);
960 case EP_PARTNER_UNSHARE
:
961 case EP_PARTNER_COMPLETE
:
963 set_bit(src_epid
, &adapter
->unshare_watch_bitmask
);
964 if (!work_pending(&adapter
->unshare_watch_task
))
965 queue_work(adapter
->control_wq
,
966 &adapter
->unshare_watch_task
);
968 case EP_PARTNER_SHARED
:
969 set_bit(src_epid
, &hw
->epstop_req_bit
);
971 if (!work_pending(&hw
->epstop_task
))
972 queue_work(adapter
->control_wq
, &hw
->epstop_task
);
975 trace_fjes_stop_req_irq_post(hw
, src_epid
);
978 static void fjes_update_zone_irq(struct fjes_adapter
*adapter
,
981 struct fjes_hw
*hw
= &adapter
->hw
;
983 if (!work_pending(&hw
->update_zone_task
))
984 queue_work(adapter
->control_wq
, &hw
->update_zone_task
);
987 static irqreturn_t
fjes_intr(int irq
, void *data
)
989 struct fjes_adapter
*adapter
= data
;
990 struct fjes_hw
*hw
= &adapter
->hw
;
994 icr
= fjes_hw_capture_interrupt_status(hw
);
996 if (icr
& REG_IS_MASK_IS_ASSERT
) {
997 if (icr
& REG_ICTL_MASK_RX_DATA
) {
998 fjes_rx_irq(adapter
, icr
& REG_IS_MASK_EPID
);
999 hw
->ep_shm_info
[icr
& REG_IS_MASK_EPID
].ep_stats
1003 if (icr
& REG_ICTL_MASK_DEV_STOP_REQ
) {
1004 fjes_stop_req_irq(adapter
, icr
& REG_IS_MASK_EPID
);
1005 hw
->ep_shm_info
[icr
& REG_IS_MASK_EPID
].ep_stats
1006 .recv_intr_stop
+= 1;
1009 if (icr
& REG_ICTL_MASK_TXRX_STOP_REQ
) {
1010 fjes_txrx_stop_req_irq(adapter
, icr
& REG_IS_MASK_EPID
);
1011 hw
->ep_shm_info
[icr
& REG_IS_MASK_EPID
].ep_stats
1012 .recv_intr_unshare
+= 1;
1015 if (icr
& REG_ICTL_MASK_TXRX_STOP_DONE
)
1016 fjes_hw_set_irqmask(hw
,
1017 REG_ICTL_MASK_TXRX_STOP_DONE
, true);
1019 if (icr
& REG_ICTL_MASK_INFO_UPDATE
) {
1020 fjes_update_zone_irq(adapter
, icr
& REG_IS_MASK_EPID
);
1021 hw
->ep_shm_info
[icr
& REG_IS_MASK_EPID
].ep_stats
1022 .recv_intr_zoneupdate
+= 1;
1033 static int fjes_rxframe_search_exist(struct fjes_adapter
*adapter
,
1036 struct fjes_hw
*hw
= &adapter
->hw
;
1037 enum ep_partner_status pstatus
;
1038 int max_epid
, cur_epid
;
1041 max_epid
= hw
->max_epid
;
1042 start_epid
= (start_epid
+ 1 + max_epid
) % max_epid
;
1044 for (i
= 0; i
< max_epid
; i
++) {
1045 cur_epid
= (start_epid
+ i
) % max_epid
;
1046 if (cur_epid
== hw
->my_epid
)
1049 pstatus
= fjes_hw_get_partner_ep_status(hw
, cur_epid
);
1050 if (pstatus
== EP_PARTNER_SHARED
) {
1051 if (!fjes_hw_epbuf_rx_is_empty(
1052 &hw
->ep_shm_info
[cur_epid
].rx
))
1059 static void *fjes_rxframe_get(struct fjes_adapter
*adapter
, size_t *psize
,
1064 *cur_epid
= fjes_rxframe_search_exist(adapter
, *cur_epid
);
1069 fjes_hw_epbuf_rx_curpkt_get_addr(
1070 &adapter
->hw
.ep_shm_info
[*cur_epid
].rx
, psize
);
1075 static void fjes_rxframe_release(struct fjes_adapter
*adapter
, int cur_epid
)
1077 fjes_hw_epbuf_rx_curpkt_drop(&adapter
->hw
.ep_shm_info
[cur_epid
].rx
);
1080 static void fjes_rx_irq(struct fjes_adapter
*adapter
, int src_epid
)
1082 struct fjes_hw
*hw
= &adapter
->hw
;
1084 fjes_hw_set_irqmask(hw
, REG_ICTL_MASK_RX_DATA
, true);
1086 adapter
->unset_rx_last
= true;
1087 napi_schedule(&adapter
->napi
);
1090 static int fjes_poll(struct napi_struct
*napi
, int budget
)
1092 struct fjes_adapter
*adapter
=
1093 container_of(napi
, struct fjes_adapter
, napi
);
1094 struct net_device
*netdev
= napi
->dev
;
1095 struct fjes_hw
*hw
= &adapter
->hw
;
1096 struct sk_buff
*skb
;
1103 spin_lock(&hw
->rx_status_lock
);
1104 for (epidx
= 0; epidx
< hw
->max_epid
; epidx
++) {
1105 if (epidx
== hw
->my_epid
)
1108 if (fjes_hw_get_partner_ep_status(hw
, epidx
) ==
1110 adapter
->hw
.ep_shm_info
[epidx
]
1111 .tx
.info
->v1i
.rx_status
|= FJES_RX_POLL_WORK
;
1113 spin_unlock(&hw
->rx_status_lock
);
1115 while (work_done
< budget
) {
1116 prefetch(&adapter
->hw
);
1117 frame
= fjes_rxframe_get(adapter
, &frame_len
, &cur_epid
);
1120 skb
= napi_alloc_skb(napi
, frame_len
);
1122 adapter
->stats64
.rx_dropped
+= 1;
1123 hw
->ep_shm_info
[cur_epid
].net_stats
1125 adapter
->stats64
.rx_errors
+= 1;
1126 hw
->ep_shm_info
[cur_epid
].net_stats
1129 memcpy(skb_put(skb
, frame_len
),
1131 skb
->protocol
= eth_type_trans(skb
, netdev
);
1132 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
1134 netif_receive_skb(skb
);
1138 adapter
->stats64
.rx_packets
+= 1;
1139 hw
->ep_shm_info
[cur_epid
].net_stats
1141 adapter
->stats64
.rx_bytes
+= frame_len
;
1142 hw
->ep_shm_info
[cur_epid
].net_stats
1143 .rx_bytes
+= frame_len
;
1145 if (is_multicast_ether_addr(
1146 ((struct ethhdr
*)frame
)->h_dest
)) {
1147 adapter
->stats64
.multicast
+= 1;
1148 hw
->ep_shm_info
[cur_epid
].net_stats
1153 fjes_rxframe_release(adapter
, cur_epid
);
1154 adapter
->unset_rx_last
= true;
1160 if (work_done
< budget
) {
1161 napi_complete(napi
);
1163 if (adapter
->unset_rx_last
) {
1164 adapter
->rx_last_jiffies
= jiffies
;
1165 adapter
->unset_rx_last
= false;
1168 if (((long)jiffies
- (long)adapter
->rx_last_jiffies
) < 3) {
1169 napi_reschedule(napi
);
1171 spin_lock(&hw
->rx_status_lock
);
1172 for (epidx
= 0; epidx
< hw
->max_epid
; epidx
++) {
1173 if (epidx
== hw
->my_epid
)
1175 if (fjes_hw_get_partner_ep_status(hw
, epidx
) ==
1177 adapter
->hw
.ep_shm_info
[epidx
].tx
1178 .info
->v1i
.rx_status
&=
1181 spin_unlock(&hw
->rx_status_lock
);
1183 fjes_hw_set_irqmask(hw
, REG_ICTL_MASK_RX_DATA
, false);
1190 /* fjes_probe - Device Initialization Routine */
1191 static int fjes_probe(struct platform_device
*plat_dev
)
1193 struct fjes_adapter
*adapter
;
1194 struct net_device
*netdev
;
1195 struct resource
*res
;
1200 netdev
= alloc_netdev_mq(sizeof(struct fjes_adapter
), "es%d",
1201 NET_NAME_UNKNOWN
, fjes_netdev_setup
,
1207 SET_NETDEV_DEV(netdev
, &plat_dev
->dev
);
1209 dev_set_drvdata(&plat_dev
->dev
, netdev
);
1210 adapter
= netdev_priv(netdev
);
1211 adapter
->netdev
= netdev
;
1212 adapter
->plat_dev
= plat_dev
;
1216 /* setup the private structure */
1217 err
= fjes_sw_init(adapter
);
1219 goto err_free_netdev
;
1221 INIT_WORK(&adapter
->force_close_task
, fjes_force_close_task
);
1222 adapter
->force_reset
= false;
1223 adapter
->open_guard
= false;
1225 adapter
->txrx_wq
= alloc_workqueue(DRV_NAME
"/txrx", WQ_MEM_RECLAIM
, 0);
1226 adapter
->control_wq
= alloc_workqueue(DRV_NAME
"/control",
1229 INIT_WORK(&adapter
->tx_stall_task
, fjes_tx_stall_task
);
1230 INIT_WORK(&adapter
->raise_intr_rxdata_task
,
1231 fjes_raise_intr_rxdata_task
);
1232 INIT_WORK(&adapter
->unshare_watch_task
, fjes_watch_unshare_task
);
1233 adapter
->unshare_watch_bitmask
= 0;
1235 INIT_DELAYED_WORK(&adapter
->interrupt_watch_task
, fjes_irq_watch_task
);
1236 adapter
->interrupt_watch_enable
= false;
1238 res
= platform_get_resource(plat_dev
, IORESOURCE_MEM
, 0);
1239 hw
->hw_res
.start
= res
->start
;
1240 hw
->hw_res
.size
= resource_size(res
);
1241 hw
->hw_res
.irq
= platform_get_irq(plat_dev
, 0);
1242 err
= fjes_hw_init(&adapter
->hw
);
1244 goto err_free_netdev
;
1246 /* setup MAC address (02:00:00:00:00:[epid])*/
1247 netdev
->dev_addr
[0] = 2;
1248 netdev
->dev_addr
[1] = 0;
1249 netdev
->dev_addr
[2] = 0;
1250 netdev
->dev_addr
[3] = 0;
1251 netdev
->dev_addr
[4] = 0;
1252 netdev
->dev_addr
[5] = hw
->my_epid
; /* EPID */
1254 err
= register_netdev(netdev
);
1258 netif_carrier_off(netdev
);
1260 fjes_dbg_adapter_init(adapter
);
1265 fjes_hw_exit(&adapter
->hw
);
1267 free_netdev(netdev
);
1272 /* fjes_remove - Device Removal Routine */
1273 static int fjes_remove(struct platform_device
*plat_dev
)
1275 struct net_device
*netdev
= dev_get_drvdata(&plat_dev
->dev
);
1276 struct fjes_adapter
*adapter
= netdev_priv(netdev
);
1277 struct fjes_hw
*hw
= &adapter
->hw
;
1279 fjes_dbg_adapter_exit(adapter
);
1281 cancel_delayed_work_sync(&adapter
->interrupt_watch_task
);
1282 cancel_work_sync(&adapter
->unshare_watch_task
);
1283 cancel_work_sync(&adapter
->raise_intr_rxdata_task
);
1284 cancel_work_sync(&adapter
->tx_stall_task
);
1285 if (adapter
->control_wq
)
1286 destroy_workqueue(adapter
->control_wq
);
1287 if (adapter
->txrx_wq
)
1288 destroy_workqueue(adapter
->txrx_wq
);
1290 unregister_netdev(netdev
);
1294 netif_napi_del(&adapter
->napi
);
1296 free_netdev(netdev
);
1301 static int fjes_sw_init(struct fjes_adapter
*adapter
)
1303 struct net_device
*netdev
= adapter
->netdev
;
1305 netif_napi_add(netdev
, &adapter
->napi
, fjes_poll
, 64);
1310 /* fjes_netdev_setup - netdevice initialization routine */
1311 static void fjes_netdev_setup(struct net_device
*netdev
)
1313 ether_setup(netdev
);
1315 netdev
->watchdog_timeo
= FJES_TX_RETRY_INTERVAL
;
1316 netdev
->netdev_ops
= &fjes_netdev_ops
;
1317 fjes_set_ethtool_ops(netdev
);
1318 netdev
->mtu
= fjes_support_mtu
[3];
1319 netdev
->flags
|= IFF_BROADCAST
;
1320 netdev
->features
|= NETIF_F_HW_CSUM
| NETIF_F_HW_VLAN_CTAG_FILTER
;
1323 static void fjes_irq_watch_task(struct work_struct
*work
)
1325 struct fjes_adapter
*adapter
= container_of(to_delayed_work(work
),
1326 struct fjes_adapter
, interrupt_watch_task
);
1328 local_irq_disable();
1329 fjes_intr(adapter
->hw
.hw_res
.irq
, adapter
);
1332 if (fjes_rxframe_search_exist(adapter
, 0) >= 0)
1333 napi_schedule(&adapter
->napi
);
1335 if (adapter
->interrupt_watch_enable
) {
1336 if (!delayed_work_pending(&adapter
->interrupt_watch_task
))
1337 queue_delayed_work(adapter
->control_wq
,
1338 &adapter
->interrupt_watch_task
,
1339 FJES_IRQ_WATCH_DELAY
);
1343 static void fjes_watch_unshare_task(struct work_struct
*work
)
1345 struct fjes_adapter
*adapter
=
1346 container_of(work
, struct fjes_adapter
, unshare_watch_task
);
1348 struct net_device
*netdev
= adapter
->netdev
;
1349 struct fjes_hw
*hw
= &adapter
->hw
;
1351 int unshare_watch
, unshare_reserve
;
1352 int max_epid
, my_epid
, epidx
;
1353 int stop_req
, stop_req_done
;
1354 ulong unshare_watch_bitmask
;
1355 unsigned long flags
;
1360 my_epid
= hw
->my_epid
;
1361 max_epid
= hw
->max_epid
;
1363 unshare_watch_bitmask
= adapter
->unshare_watch_bitmask
;
1364 adapter
->unshare_watch_bitmask
= 0;
1366 while ((unshare_watch_bitmask
|| hw
->txrx_stop_req_bit
) &&
1367 (wait_time
< 3000)) {
1368 for (epidx
= 0; epidx
< hw
->max_epid
; epidx
++) {
1369 if (epidx
== hw
->my_epid
)
1372 is_shared
= fjes_hw_epid_is_shared(hw
->hw_info
.share
,
1375 stop_req
= test_bit(epidx
, &hw
->txrx_stop_req_bit
);
1377 stop_req_done
= hw
->ep_shm_info
[epidx
].rx
.info
->v1i
.rx_status
&
1378 FJES_RX_STOP_REQ_DONE
;
1380 unshare_watch
= test_bit(epidx
, &unshare_watch_bitmask
);
1382 unshare_reserve
= test_bit(epidx
,
1383 &hw
->hw_info
.buffer_unshare_reserve_bit
);
1386 (is_shared
&& (!is_shared
|| !stop_req_done
))) &&
1387 (is_shared
|| !unshare_watch
|| !unshare_reserve
))
1390 mutex_lock(&hw
->hw_info
.lock
);
1391 ret
= fjes_hw_unregister_buff_addr(hw
, epidx
);
1399 &adapter
->force_close_task
)) {
1400 adapter
->force_reset
= true;
1402 &adapter
->force_close_task
);
1406 mutex_unlock(&hw
->hw_info
.lock
);
1407 hw
->ep_shm_info
[epidx
].ep_stats
1408 .com_unregist_buf_exec
+= 1;
1410 spin_lock_irqsave(&hw
->rx_status_lock
, flags
);
1411 fjes_hw_setup_epbuf(&hw
->ep_shm_info
[epidx
].tx
,
1412 netdev
->dev_addr
, netdev
->mtu
);
1413 spin_unlock_irqrestore(&hw
->rx_status_lock
, flags
);
1415 clear_bit(epidx
, &hw
->txrx_stop_req_bit
);
1416 clear_bit(epidx
, &unshare_watch_bitmask
);
1418 &hw
->hw_info
.buffer_unshare_reserve_bit
);
1425 if (hw
->hw_info
.buffer_unshare_reserve_bit
) {
1426 for (epidx
= 0; epidx
< hw
->max_epid
; epidx
++) {
1427 if (epidx
== hw
->my_epid
)
1431 &hw
->hw_info
.buffer_unshare_reserve_bit
)) {
1432 mutex_lock(&hw
->hw_info
.lock
);
1434 ret
= fjes_hw_unregister_buff_addr(hw
, epidx
);
1442 &adapter
->force_close_task
)) {
1443 adapter
->force_reset
= true;
1445 &adapter
->force_close_task
);
1449 mutex_unlock(&hw
->hw_info
.lock
);
1451 hw
->ep_shm_info
[epidx
].ep_stats
1452 .com_unregist_buf_exec
+= 1;
1454 spin_lock_irqsave(&hw
->rx_status_lock
, flags
);
1455 fjes_hw_setup_epbuf(
1456 &hw
->ep_shm_info
[epidx
].tx
,
1457 netdev
->dev_addr
, netdev
->mtu
);
1458 spin_unlock_irqrestore(&hw
->rx_status_lock
,
1461 clear_bit(epidx
, &hw
->txrx_stop_req_bit
);
1462 clear_bit(epidx
, &unshare_watch_bitmask
);
1463 clear_bit(epidx
, &hw
->hw_info
.buffer_unshare_reserve_bit
);
1466 if (test_bit(epidx
, &unshare_watch_bitmask
)) {
1467 spin_lock_irqsave(&hw
->rx_status_lock
, flags
);
1468 hw
->ep_shm_info
[epidx
].tx
.info
->v1i
.rx_status
&=
1469 ~FJES_RX_STOP_REQ_DONE
;
1470 spin_unlock_irqrestore(&hw
->rx_status_lock
,
1477 /* fjes_init_module - Driver Registration Routine */
1478 static int __init
fjes_init_module(void)
1482 pr_info("%s - version %s - %s\n",
1483 fjes_driver_string
, fjes_driver_version
, fjes_copyright
);
1487 result
= platform_driver_register(&fjes_driver
);
1493 result
= acpi_bus_register_driver(&fjes_acpi_driver
);
1495 goto fail_acpi_driver
;
1500 platform_driver_unregister(&fjes_driver
);
1505 module_init(fjes_init_module
);
1507 /* fjes_exit_module - Driver Exit Cleanup Routine */
1508 static void __exit
fjes_exit_module(void)
1510 acpi_bus_unregister_driver(&fjes_acpi_driver
);
1511 platform_driver_unregister(&fjes_driver
);
1515 module_exit(fjes_exit_module
);