2 * Copyright (c) 2012 GCT Semiconductor, Inc. All rights reserved.
4 * This software is licensed under the terms of the GNU General Public
5 * License version 2, as published by the Free Software Foundation, and
6 * may be copied, distributed, and modified under those terms.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
14 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
16 #include <linux/etherdevice.h>
18 #include <linux/ipv6.h>
19 #include <linux/udp.h>
21 #include <linux/if_arp.h>
22 #include <linux/if_ether.h>
23 #include <linux/if_vlan.h>
24 #include <linux/in6.h>
25 #include <linux/tcp.h>
26 #include <linux/icmp.h>
27 #include <linux/icmpv6.h>
28 #include <linux/uaccess.h>
29 #include <net/ndisc.h>
32 #include "netlink_k.h"
34 #include "hci_packet.h"
35 #include "gdm_endian.h"
38 * Netlink protocol number
40 #define NETLINK_LTE 30
45 #define DEFAULT_MTU_SIZE 1500
47 #define IP_VERSION_4 4
48 #define IP_VERSION_6 6
55 static struct device_type wwan_type
= {
59 static int gdm_lte_open(struct net_device
*dev
)
61 netif_start_queue(dev
);
65 static int gdm_lte_close(struct net_device
*dev
)
67 netif_stop_queue(dev
);
71 static int gdm_lte_set_config(struct net_device
*dev
, struct ifmap
*map
)
73 if (dev
->flags
& IFF_UP
)
78 static void tx_complete(void *arg
)
80 struct nic
*nic
= arg
;
82 if (netif_queue_stopped(nic
->netdev
))
83 netif_wake_queue(nic
->netdev
);
86 static int gdm_lte_rx(struct sk_buff
*skb
, struct nic
*nic
, int nic_type
)
90 ret
= netif_rx_ni(skb
);
91 if (ret
== NET_RX_DROP
) {
92 nic
->stats
.rx_dropped
++;
94 nic
->stats
.rx_packets
++;
95 nic
->stats
.rx_bytes
+= skb
->len
+ ETH_HLEN
;
101 static int gdm_lte_emulate_arp(struct sk_buff
*skb_in
, u32 nic_type
)
103 struct nic
*nic
= netdev_priv(skb_in
->dev
);
104 struct sk_buff
*skb_out
;
106 struct vlan_ethhdr vlan_eth
;
107 struct arphdr
*arp_in
;
108 struct arphdr
*arp_out
;
115 struct arpdata
*arp_data_in
;
116 struct arpdata
*arp_data_out
;
118 void *mac_header_data
;
121 /* Format the mac header so that it can be put to skb */
122 if (ntohs(((struct ethhdr
*)skb_in
->data
)->h_proto
) == ETH_P_8021Q
) {
123 memcpy(&vlan_eth
, skb_in
->data
, sizeof(struct vlan_ethhdr
));
124 mac_header_data
= &vlan_eth
;
125 mac_header_len
= VLAN_ETH_HLEN
;
127 memcpy(ð
, skb_in
->data
, sizeof(struct ethhdr
));
128 mac_header_data
= ð
;
129 mac_header_len
= ETH_HLEN
;
132 /* Get the pointer of the original request */
133 arp_in
= (struct arphdr
*)(skb_in
->data
+ mac_header_len
);
134 arp_data_in
= (struct arpdata
*)(skb_in
->data
+ mac_header_len
+
135 sizeof(struct arphdr
));
137 /* Get the pointer of the outgoing response */
138 arp_out
= (struct arphdr
*)arp_temp
;
139 arp_data_out
= (struct arpdata
*)(arp_temp
+ sizeof(struct arphdr
));
141 /* Copy the arp header */
142 memcpy(arp_out
, arp_in
, sizeof(struct arphdr
));
143 arp_out
->ar_op
= htons(ARPOP_REPLY
);
145 /* Copy the arp payload: based on 2 bytes of mac and fill the IP */
146 arp_data_out
->ar_sha
[0] = arp_data_in
->ar_sha
[0];
147 arp_data_out
->ar_sha
[1] = arp_data_in
->ar_sha
[1];
148 memcpy(&arp_data_out
->ar_sha
[2], &arp_data_in
->ar_tip
[0], 4);
149 memcpy(&arp_data_out
->ar_sip
[0], &arp_data_in
->ar_tip
[0], 4);
150 memcpy(&arp_data_out
->ar_tha
[0], &arp_data_in
->ar_sha
[0], 6);
151 memcpy(&arp_data_out
->ar_tip
[0], &arp_data_in
->ar_sip
[0], 4);
153 /* Fill the destination mac with source mac of the received packet */
154 memcpy(mac_header_data
, mac_header_data
+ ETH_ALEN
, ETH_ALEN
);
155 /* Fill the source mac with nic's source mac */
156 memcpy(mac_header_data
+ ETH_ALEN
, nic
->src_mac_addr
, ETH_ALEN
);
158 /* Alloc skb and reserve align */
159 skb_out
= dev_alloc_skb(skb_in
->len
);
162 skb_reserve(skb_out
, NET_IP_ALIGN
);
164 memcpy(skb_put(skb_out
, mac_header_len
), mac_header_data
,
166 memcpy(skb_put(skb_out
, sizeof(struct arphdr
)), arp_out
,
167 sizeof(struct arphdr
));
168 memcpy(skb_put(skb_out
, sizeof(struct arpdata
)), arp_data_out
,
169 sizeof(struct arpdata
));
171 skb_out
->protocol
= ((struct ethhdr
*)mac_header_data
)->h_proto
;
172 skb_out
->dev
= skb_in
->dev
;
173 skb_reset_mac_header(skb_out
);
174 skb_pull(skb_out
, ETH_HLEN
);
176 gdm_lte_rx(skb_out
, nic
, nic_type
);
181 static int icmp6_checksum(struct ipv6hdr
*ipv6
, u16
*ptr
, int len
)
183 unsigned short *w
= ptr
;
198 memset(&pseudo_header
, 0, sizeof(pseudo_header
));
199 memcpy(&pseudo_header
.ph
.ph_src
, &ipv6
->saddr
.in6_u
.u6_addr8
, 16);
200 memcpy(&pseudo_header
.ph
.ph_dst
, &ipv6
->daddr
.in6_u
.u6_addr8
, 16);
201 pseudo_header
.ph
.ph_len
= ipv6
->payload_len
;
202 pseudo_header
.ph
.ph_nxt
= ipv6
->nexthdr
;
204 w
= (u16
*)&pseudo_header
;
205 for (i
= 0; i
< ARRAY_SIZE(pseudo_header
.pa
); i
++)
206 sum
+= pseudo_header
.pa
[i
];
214 sum
= (sum
>> 16) + (sum
& 0xFFFF);
221 static int gdm_lte_emulate_ndp(struct sk_buff
*skb_in
, u32 nic_type
)
223 struct nic
*nic
= netdev_priv(skb_in
->dev
);
224 struct sk_buff
*skb_out
;
226 struct vlan_ethhdr vlan_eth
;
227 struct neighbour_advertisement
{
228 u8 target_address
[16];
231 u8 link_layer_address
[6];
233 struct neighbour_advertisement na
;
234 struct neighbour_solicitation
{
235 u8 target_address
[16];
237 struct neighbour_solicitation
*ns
;
238 struct ipv6hdr
*ipv6_in
;
239 struct ipv6hdr ipv6_out
;
240 struct icmp6hdr
*icmp6_in
;
241 struct icmp6hdr icmp6_out
;
243 void *mac_header_data
;
246 /* Format the mac header so that it can be put to skb */
247 if (ntohs(((struct ethhdr
*)skb_in
->data
)->h_proto
) == ETH_P_8021Q
) {
248 memcpy(&vlan_eth
, skb_in
->data
, sizeof(struct vlan_ethhdr
));
249 if (ntohs(vlan_eth
.h_vlan_encapsulated_proto
) != ETH_P_IPV6
)
251 mac_header_data
= &vlan_eth
;
252 mac_header_len
= VLAN_ETH_HLEN
;
254 memcpy(ð
, skb_in
->data
, sizeof(struct ethhdr
));
255 if (ntohs(eth
.h_proto
) != ETH_P_IPV6
)
257 mac_header_data
= ð
;
258 mac_header_len
= ETH_HLEN
;
261 /* Check if this is IPv6 ICMP packet */
262 ipv6_in
= (struct ipv6hdr
*)(skb_in
->data
+ mac_header_len
);
263 if (ipv6_in
->version
!= 6 || ipv6_in
->nexthdr
!= IPPROTO_ICMPV6
)
266 /* Check if this is NDP packet */
267 icmp6_in
= (struct icmp6hdr
*)(skb_in
->data
+ mac_header_len
+
268 sizeof(struct ipv6hdr
));
269 if (icmp6_in
->icmp6_type
== NDISC_ROUTER_SOLICITATION
) { /* Check RS */
271 } else if (icmp6_in
->icmp6_type
== NDISC_NEIGHBOUR_SOLICITATION
) {
273 u8 icmp_na
[sizeof(struct icmp6hdr
) +
274 sizeof(struct neighbour_advertisement
)];
275 u8 zero_addr8
[16] = {0,};
277 if (memcmp(ipv6_in
->saddr
.in6_u
.u6_addr8
, zero_addr8
, 16) == 0)
278 /* Duplicate Address Detection: Source IP is all zero */
281 icmp6_out
.icmp6_type
= NDISC_NEIGHBOUR_ADVERTISEMENT
;
282 icmp6_out
.icmp6_code
= 0;
283 icmp6_out
.icmp6_cksum
= 0;
285 icmp6_out
.icmp6_dataun
.un_data32
[0] = htonl(0x60000000);
287 ns
= (struct neighbour_solicitation
*)
288 (skb_in
->data
+ mac_header_len
+
289 sizeof(struct ipv6hdr
) + sizeof(struct icmp6hdr
));
290 memcpy(&na
.target_address
, ns
->target_address
, 16);
293 na
.link_layer_address
[0] = 0x00;
294 na
.link_layer_address
[1] = 0x0a;
295 na
.link_layer_address
[2] = 0x3b;
296 na
.link_layer_address
[3] = 0xaf;
297 na
.link_layer_address
[4] = 0x63;
298 na
.link_layer_address
[5] = 0xc7;
300 memcpy(&ipv6_out
, ipv6_in
, sizeof(struct ipv6hdr
));
301 memcpy(ipv6_out
.saddr
.in6_u
.u6_addr8
, &na
.target_address
, 16);
302 memcpy(ipv6_out
.daddr
.in6_u
.u6_addr8
,
303 ipv6_in
->saddr
.in6_u
.u6_addr8
, 16);
304 ipv6_out
.payload_len
= htons(sizeof(struct icmp6hdr
) +
305 sizeof(struct neighbour_advertisement
));
307 memcpy(icmp_na
, &icmp6_out
, sizeof(struct icmp6hdr
));
308 memcpy(icmp_na
+ sizeof(struct icmp6hdr
), &na
,
309 sizeof(struct neighbour_advertisement
));
311 icmp6_out
.icmp6_cksum
= icmp6_checksum(&ipv6_out
,
312 (u16
*)icmp_na
, sizeof(icmp_na
));
317 /* Fill the destination mac with source mac of the received packet */
318 memcpy(mac_header_data
, mac_header_data
+ ETH_ALEN
, ETH_ALEN
);
319 /* Fill the source mac with nic's source mac */
320 memcpy(mac_header_data
+ ETH_ALEN
, nic
->src_mac_addr
, ETH_ALEN
);
322 /* Alloc skb and reserve align */
323 skb_out
= dev_alloc_skb(skb_in
->len
);
326 skb_reserve(skb_out
, NET_IP_ALIGN
);
328 memcpy(skb_put(skb_out
, mac_header_len
), mac_header_data
,
330 memcpy(skb_put(skb_out
, sizeof(struct ipv6hdr
)), &ipv6_out
,
331 sizeof(struct ipv6hdr
));
332 memcpy(skb_put(skb_out
, sizeof(struct icmp6hdr
)), &icmp6_out
,
333 sizeof(struct icmp6hdr
));
334 memcpy(skb_put(skb_out
, sizeof(struct neighbour_advertisement
)), &na
,
335 sizeof(struct neighbour_advertisement
));
337 skb_out
->protocol
= ((struct ethhdr
*)mac_header_data
)->h_proto
;
338 skb_out
->dev
= skb_in
->dev
;
339 skb_reset_mac_header(skb_out
);
340 skb_pull(skb_out
, ETH_HLEN
);
342 gdm_lte_rx(skb_out
, nic
, nic_type
);
347 static s32
gdm_lte_tx_nic_type(struct net_device
*dev
, struct sk_buff
*skb
)
349 struct nic
*nic
= netdev_priv(dev
);
351 struct vlan_ethhdr
*vlan_eth
;
353 struct ipv6hdr
*ipv6
;
358 /* NIC TYPE is based on the nic_id of this net_device */
359 nic_type
= 0x00000010 | nic
->nic_id
;
361 /* Get ethernet protocol */
362 eth
= (struct ethhdr
*)skb
->data
;
363 if (ntohs(eth
->h_proto
) == ETH_P_8021Q
) {
364 vlan_eth
= (struct vlan_ethhdr
*)skb
->data
;
365 mac_proto
= ntohs(vlan_eth
->h_vlan_encapsulated_proto
);
366 network_data
= skb
->data
+ VLAN_ETH_HLEN
;
367 nic_type
|= NIC_TYPE_F_VLAN
;
369 mac_proto
= ntohs(eth
->h_proto
);
370 network_data
= skb
->data
+ ETH_HLEN
;
373 /* Process packet for nic type */
376 nic_type
|= NIC_TYPE_ARP
;
379 nic_type
|= NIC_TYPE_F_IPV4
;
380 ip
= (struct iphdr
*)network_data
;
383 if (ip
->protocol
== IPPROTO_UDP
) {
384 struct udphdr
*udp
= (struct udphdr
*)
385 (network_data
+ sizeof(struct iphdr
));
386 if (ntohs(udp
->dest
) == 67 || ntohs(udp
->dest
) == 68)
387 nic_type
|= NIC_TYPE_F_DHCP
;
391 nic_type
|= NIC_TYPE_F_IPV6
;
392 ipv6
= (struct ipv6hdr
*)network_data
;
394 if (ipv6
->nexthdr
== IPPROTO_ICMPV6
) /* Check NDP request */ {
395 struct icmp6hdr
*icmp6
= (struct icmp6hdr
*)
396 (network_data
+ sizeof(struct ipv6hdr
));
397 if (icmp6
->icmp6_type
== NDISC_NEIGHBOUR_SOLICITATION
)
398 nic_type
|= NIC_TYPE_ICMPV6
;
399 } else if (ipv6
->nexthdr
== IPPROTO_UDP
) /* Check DHCPv6 */ {
400 struct udphdr
*udp
= (struct udphdr
*)
401 (network_data
+ sizeof(struct ipv6hdr
));
402 if (ntohs(udp
->dest
) == 546 || ntohs(udp
->dest
) == 547)
403 nic_type
|= NIC_TYPE_F_DHCP
;
413 static int gdm_lte_tx(struct sk_buff
*skb
, struct net_device
*dev
)
415 struct nic
*nic
= netdev_priv(dev
);
422 nic_type
= gdm_lte_tx_nic_type(dev
, skb
);
424 netdev_err(dev
, "tx - invalid nic_type\n");
428 if (nic_type
& NIC_TYPE_ARP
) {
429 if (gdm_lte_emulate_arp(skb
, nic_type
) == 0) {
435 if (nic_type
& NIC_TYPE_ICMPV6
) {
436 if (gdm_lte_emulate_ndp(skb
, nic_type
) == 0) {
443 * Need byte shift (that is, remove VLAN tag) if there is one
444 * For the case of ARP, this breaks the offset as vlan_ethhdr+4
445 * is treated as ethhdr However, it shouldn't be a problem as
446 * the response starts from arp_hdr and ethhdr is created by this
447 * driver based on the NIC mac
449 if (nic_type
& NIC_TYPE_F_VLAN
) {
450 struct vlan_ethhdr
*vlan_eth
= (struct vlan_ethhdr
*)skb
->data
;
452 nic
->vlan_id
= ntohs(vlan_eth
->h_vlan_TCI
) & VLAN_VID_MASK
;
453 data_buf
= skb
->data
+ (VLAN_ETH_HLEN
- ETH_HLEN
);
454 data_len
= skb
->len
- (VLAN_ETH_HLEN
- ETH_HLEN
);
457 data_buf
= skb
->data
;
461 /* If it is a ICMPV6 packet, clear all the other bits :
462 * for backward compatibility with the firmware
464 if (nic_type
& NIC_TYPE_ICMPV6
)
465 nic_type
= NIC_TYPE_ICMPV6
;
467 /* If it is not a dhcp packet, clear all the flag bits :
468 * original NIC, otherwise the special flag (IPVX | DHCP)
470 if (!(nic_type
& NIC_TYPE_F_DHCP
))
471 nic_type
&= NIC_TYPE_MASK
;
473 ret
= sscanf(dev
->name
, "lte%d", &idx
);
479 ret
= nic
->phy_dev
->send_sdu_func(nic
->phy_dev
->priv_dev
,
481 nic
->pdn_table
.dft_eps_id
, 0,
482 tx_complete
, nic
, idx
,
485 if (ret
== TX_NO_BUFFER
|| ret
== TX_NO_SPC
) {
486 netif_stop_queue(dev
);
487 if (ret
== TX_NO_BUFFER
)
491 } else if (ret
== TX_NO_DEV
) {
495 /* Updates tx stats */
497 nic
->stats
.tx_dropped
++;
499 nic
->stats
.tx_packets
++;
500 nic
->stats
.tx_bytes
+= data_len
;
507 static struct net_device_stats
*gdm_lte_stats(struct net_device
*dev
)
509 struct nic
*nic
= netdev_priv(dev
);
514 static int gdm_lte_event_send(struct net_device
*dev
, char *buf
, int len
)
516 struct nic
*nic
= netdev_priv(dev
);
517 struct hci_packet
*hci
= (struct hci_packet
*)buf
;
521 ret
= sscanf(dev
->name
, "lte%d", &idx
);
525 return netlink_send(lte_event
.sock
, idx
, 0, buf
,
527 nic
->phy_dev
->get_endian(
528 nic
->phy_dev
->priv_dev
), hci
->len
)
532 static void gdm_lte_event_rcv(struct net_device
*dev
, u16 type
,
535 struct nic
*nic
= netdev_priv(dev
);
537 nic
->phy_dev
->send_hci_func(nic
->phy_dev
->priv_dev
, msg
, len
, NULL
,
541 int gdm_lte_event_init(void)
543 if (lte_event
.ref_cnt
== 0)
544 lte_event
.sock
= netlink_init(NETLINK_LTE
, gdm_lte_event_rcv
);
546 if (lte_event
.sock
) {
551 pr_err("event init failed\n");
555 void gdm_lte_event_exit(void)
557 if (lte_event
.sock
&& --lte_event
.ref_cnt
== 0) {
558 netlink_exit(lte_event
.sock
);
559 lte_event
.sock
= NULL
;
563 static u8
find_dev_index(u32 nic_type
)
567 index
= (u8
)(nic_type
& 0x0000000f);
568 if (index
> MAX_NIC_TYPE
)
574 static void gdm_lte_netif_rx(struct net_device
*dev
, char *buf
,
575 int len
, int flagged_nic_type
)
581 struct vlan_ethhdr vlan_eth
;
582 void *mac_header_data
;
586 nic_type
= flagged_nic_type
& NIC_TYPE_MASK
;
587 nic
= netdev_priv(dev
);
589 if (flagged_nic_type
& NIC_TYPE_F_DHCP
) {
590 /* Change the destination mac address
591 * with the one requested the IP
593 if (flagged_nic_type
& NIC_TYPE_F_IPV4
) {
595 u8 op
; /* BOOTREQUEST or BOOTREPLY */
596 u8 htype
; /* hardware address type.
599 u8 hlen
; /* hardware address length */
600 u8 hops
; /* used by relay agents only */
601 u32 xid
; /* unique id */
602 u16 secs
; /* elapsed since client began
603 * acquisition/renewal
605 u16 flags
; /* only one flag so far: */
606 #define BROADCAST_FLAG 0x8000
607 /* "I need broadcast replies" */
608 u32 ciaddr
; /* client IP (if client is in
609 * BOUND, RENEW or REBINDING state)
611 u32 yiaddr
; /* 'your' (client) IP address */
612 /* IP address of next server to use in
613 * bootstrap, returned in DHCPOFFER,
617 u32 gateway_nip
; /* relay agent IP address */
618 u8 chaddr
[16]; /* link-layer client hardware
621 u8 sname
[64]; /* server host name (ASCIZ) */
622 u8 file
[128]; /* boot file name (ASCIZ) */
623 u32 cookie
; /* fixed first four option
624 * bytes (99,130,83,99 dec)
627 void *addr
= buf
+ sizeof(struct iphdr
) +
628 sizeof(struct udphdr
) +
629 offsetof(struct dhcp_packet
, chaddr
);
630 ether_addr_copy(nic
->dest_mac_addr
, addr
);
634 if (nic
->vlan_id
> 0) {
635 mac_header_data
= (void *)&vlan_eth
;
636 mac_header_len
= VLAN_ETH_HLEN
;
638 mac_header_data
= (void *)ð
;
639 mac_header_len
= ETH_HLEN
;
642 /* Format the data so that it can be put to skb */
643 ether_addr_copy(mac_header_data
, nic
->dest_mac_addr
);
644 memcpy(mac_header_data
+ ETH_ALEN
, nic
->src_mac_addr
, ETH_ALEN
);
646 vlan_eth
.h_vlan_TCI
= htons(nic
->vlan_id
);
647 vlan_eth
.h_vlan_proto
= htons(ETH_P_8021Q
);
649 if (nic_type
== NIC_TYPE_ARP
) {
650 /* Should be response: Only happens because
651 * there was a request from the host
653 eth
.h_proto
= htons(ETH_P_ARP
);
654 vlan_eth
.h_vlan_encapsulated_proto
= htons(ETH_P_ARP
);
656 ip_version
= buf
[0] >> 4;
657 if (ip_version
== IP_VERSION_4
) {
658 eth
.h_proto
= htons(ETH_P_IP
);
659 vlan_eth
.h_vlan_encapsulated_proto
= htons(ETH_P_IP
);
660 } else if (ip_version
== IP_VERSION_6
) {
661 eth
.h_proto
= htons(ETH_P_IPV6
);
662 vlan_eth
.h_vlan_encapsulated_proto
= htons(ETH_P_IPV6
);
664 netdev_err(dev
, "Unknown IP version %d\n", ip_version
);
669 /* Alloc skb and reserve align */
670 skb
= dev_alloc_skb(len
+ mac_header_len
+ NET_IP_ALIGN
);
673 skb_reserve(skb
, NET_IP_ALIGN
);
675 memcpy(skb_put(skb
, mac_header_len
), mac_header_data
, mac_header_len
);
676 memcpy(skb_put(skb
, len
), buf
, len
);
678 skb
->protocol
= ((struct ethhdr
*)mac_header_data
)->h_proto
;
680 skb_reset_mac_header(skb
);
681 skb_pull(skb
, ETH_HLEN
);
683 gdm_lte_rx(skb
, nic
, nic_type
);
686 static void gdm_lte_multi_sdu_pkt(struct phy_dev
*phy_dev
, char *buf
, int len
)
688 struct net_device
*dev
;
689 struct multi_sdu
*multi_sdu
= (struct multi_sdu
*)buf
;
690 struct sdu
*sdu
= NULL
;
691 u8
*data
= (u8
*)multi_sdu
->data
;
699 hci_len
= gdm_dev16_to_cpu(phy_dev
->get_endian(phy_dev
->priv_dev
),
701 num_packet
= gdm_dev16_to_cpu(phy_dev
->get_endian(phy_dev
->priv_dev
),
702 multi_sdu
->num_packet
);
704 for (i
= 0; i
< num_packet
; i
++) {
705 sdu
= (struct sdu
*)data
;
707 cmd_evt
= gdm_dev16_to_cpu(phy_dev
->
708 get_endian(phy_dev
->priv_dev
), sdu
->cmd_evt
);
709 hci_len
= gdm_dev16_to_cpu(phy_dev
->
710 get_endian(phy_dev
->priv_dev
), sdu
->len
);
711 nic_type
= gdm_dev32_to_cpu(phy_dev
->
712 get_endian(phy_dev
->priv_dev
), sdu
->nic_type
);
714 if (cmd_evt
!= LTE_RX_SDU
) {
715 pr_err("rx sdu wrong hci %04x\n", cmd_evt
);
719 pr_err("rx sdu invalid len %d\n", hci_len
);
723 index
= find_dev_index(nic_type
);
724 if (index
< MAX_NIC_TYPE
) {
725 dev
= phy_dev
->dev
[index
];
726 gdm_lte_netif_rx(dev
, (char *)sdu
->data
,
727 (int)(hci_len
-12), nic_type
);
729 pr_err("rx sdu invalid nic_type :%x\n", nic_type
);
732 data
+= ((hci_len
+3) & 0xfffc) + HCI_HEADER_SIZE
;
736 static void gdm_lte_pdn_table(struct net_device
*dev
, char *buf
, int len
)
738 struct nic
*nic
= netdev_priv(dev
);
739 struct hci_pdn_table_ind
*pdn_table
= (struct hci_pdn_table_ind
*)buf
;
741 if (pdn_table
->activate
) {
742 nic
->pdn_table
.activate
= pdn_table
->activate
;
743 nic
->pdn_table
.dft_eps_id
= gdm_dev32_to_cpu(
744 nic
->phy_dev
->get_endian(
745 nic
->phy_dev
->priv_dev
),
746 pdn_table
->dft_eps_id
);
747 nic
->pdn_table
.nic_type
= gdm_dev32_to_cpu(
748 nic
->phy_dev
->get_endian(
749 nic
->phy_dev
->priv_dev
),
750 pdn_table
->nic_type
);
752 netdev_info(dev
, "pdn activated, nic_type=0x%x\n",
753 nic
->pdn_table
.nic_type
);
755 memset(&nic
->pdn_table
, 0x00, sizeof(struct pdn_table
));
756 netdev_info(dev
, "pdn deactivated\n");
760 static int gdm_lte_receive_pkt(struct phy_dev
*phy_dev
, char *buf
, int len
)
762 struct hci_packet
*hci
= (struct hci_packet
*)buf
;
763 struct hci_pdn_table_ind
*pdn_table
= (struct hci_pdn_table_ind
*)buf
;
765 struct net_device
*dev
;
774 cmd_evt
= gdm_dev16_to_cpu(phy_dev
->get_endian(phy_dev
->priv_dev
),
777 dev
= phy_dev
->dev
[0];
783 sdu
= (struct sdu
*)hci
->data
;
784 nic_type
= gdm_dev32_to_cpu(phy_dev
->
785 get_endian(phy_dev
->priv_dev
), sdu
->nic_type
);
786 index
= find_dev_index(nic_type
);
787 dev
= phy_dev
->dev
[index
];
788 gdm_lte_netif_rx(dev
, hci
->data
, len
, nic_type
);
790 case LTE_RX_MULTI_SDU
:
791 gdm_lte_multi_sdu_pkt(phy_dev
, buf
, len
);
793 case LTE_LINK_ON_OFF_INDICATION
:
794 netdev_info(dev
, "link %s\n",
795 ((struct hci_connect_ind
*)buf
)->connect
798 case LTE_PDN_TABLE_IND
:
799 pdn_table
= (struct hci_pdn_table_ind
*)buf
;
800 nic_type
= gdm_dev32_to_cpu(phy_dev
->
801 get_endian(phy_dev
->priv_dev
),
802 pdn_table
->nic_type
);
803 index
= find_dev_index(nic_type
);
804 dev
= phy_dev
->dev
[index
];
805 gdm_lte_pdn_table(dev
, buf
, len
);
808 ret
= gdm_lte_event_send(dev
, buf
, len
);
815 static int rx_complete(void *arg
, void *data
, int len
, int context
)
817 struct phy_dev
*phy_dev
= (struct phy_dev
*)arg
;
819 return gdm_lte_receive_pkt(phy_dev
, (char *)data
, len
);
822 void start_rx_proc(struct phy_dev
*phy_dev
)
826 for (i
= 0; i
< MAX_RX_SUBMIT_COUNT
; i
++)
827 phy_dev
->rcv_func(phy_dev
->priv_dev
,
828 rx_complete
, phy_dev
, USB_COMPLETE
);
831 static struct net_device_ops gdm_netdev_ops
= {
832 .ndo_open
= gdm_lte_open
,
833 .ndo_stop
= gdm_lte_close
,
834 .ndo_set_config
= gdm_lte_set_config
,
835 .ndo_start_xmit
= gdm_lte_tx
,
836 .ndo_get_stats
= gdm_lte_stats
,
839 static u8 gdm_lte_macaddr
[ETH_ALEN
] = {0x00, 0x0a, 0x3b, 0x00, 0x00, 0x00};
841 static void form_mac_address(u8
*dev_addr
, u8
*nic_src
, u8
*nic_dest
,
842 u8
*mac_address
, u8 index
)
844 /* Form the dev_addr */
846 ether_addr_copy(dev_addr
, gdm_lte_macaddr
);
848 ether_addr_copy(dev_addr
, mac_address
);
850 /* The last byte of the mac address
851 * should be less than or equal to 0xFC
853 dev_addr
[ETH_ALEN
-1] += index
;
855 /* Create random nic src and copy the first
856 * 3 bytes to be the same as dev_addr
858 random_ether_addr(nic_src
);
859 memcpy(nic_src
, dev_addr
, 3);
861 /* Copy the nic_dest from dev_addr*/
862 ether_addr_copy(nic_dest
, dev_addr
);
865 static void validate_mac_address(u8
*mac_address
)
867 /* if zero address or multicast bit set, restore the default value */
868 if (is_zero_ether_addr(mac_address
) || (mac_address
[0] & 0x01)) {
869 pr_err("MAC invalid, restoring default\n");
870 memcpy(mac_address
, gdm_lte_macaddr
, 6);
874 int register_lte_device(struct phy_dev
*phy_dev
,
875 struct device
*dev
, u8
*mac_address
)
878 struct net_device
*net
;
879 char pdn_dev_name
[16];
883 validate_mac_address(mac_address
);
885 for (index
= 0; index
< MAX_NIC_TYPE
; index
++) {
886 /* Create device name lteXpdnX */
887 sprintf(pdn_dev_name
, "lte%%dpdn%d", index
);
889 /* Allocate netdev */
890 net
= alloc_netdev(sizeof(struct nic
), pdn_dev_name
,
891 NET_NAME_UNKNOWN
, ether_setup
);
893 pr_err("alloc_netdev failed\n");
897 net
->netdev_ops
= &gdm_netdev_ops
;
898 net
->flags
&= ~IFF_MULTICAST
;
899 net
->mtu
= DEFAULT_MTU_SIZE
;
901 nic
= netdev_priv(net
);
902 memset(nic
, 0, sizeof(struct nic
));
904 nic
->phy_dev
= phy_dev
;
914 SET_NETDEV_DEV(net
, dev
);
915 SET_NETDEV_DEVTYPE(net
, &wwan_type
);
917 ret
= register_netdev(net
);
921 netif_carrier_on(net
);
923 phy_dev
->dev
[index
] = net
;
929 unregister_lte_device(phy_dev
);
934 void unregister_lte_device(struct phy_dev
*phy_dev
)
936 struct net_device
*net
;
939 for (index
= 0; index
< MAX_NIC_TYPE
; index
++) {
940 net
= phy_dev
->dev
[index
];
944 unregister_netdev(net
);