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;
284 icmp6_out
.icmp6_dataun
.un_data32
[0] = htonl(0x60000000); /* R=0, S=1, O=1 */
286 ns
= (struct neighbour_solicitation
*)
287 (skb_in
->data
+ mac_header_len
+
288 sizeof(struct ipv6hdr
) + sizeof(struct icmp6hdr
));
289 memcpy(&na
.target_address
, ns
->target_address
, 16);
292 na
.link_layer_address
[0] = 0x00;
293 na
.link_layer_address
[1] = 0x0a;
294 na
.link_layer_address
[2] = 0x3b;
295 na
.link_layer_address
[3] = 0xaf;
296 na
.link_layer_address
[4] = 0x63;
297 na
.link_layer_address
[5] = 0xc7;
299 memcpy(&ipv6_out
, ipv6_in
, sizeof(struct ipv6hdr
));
300 memcpy(ipv6_out
.saddr
.in6_u
.u6_addr8
, &na
.target_address
, 16);
301 memcpy(ipv6_out
.daddr
.in6_u
.u6_addr8
,
302 ipv6_in
->saddr
.in6_u
.u6_addr8
, 16);
303 ipv6_out
.payload_len
= htons(sizeof(struct icmp6hdr
) +
304 sizeof(struct neighbour_advertisement
));
306 memcpy(icmp_na
, &icmp6_out
, sizeof(struct icmp6hdr
));
307 memcpy(icmp_na
+ sizeof(struct icmp6hdr
), &na
,
308 sizeof(struct neighbour_advertisement
));
310 icmp6_out
.icmp6_cksum
= icmp6_checksum(&ipv6_out
,
311 (u16
*)icmp_na
, sizeof(icmp_na
));
316 /* Fill the destination mac with source mac of the received packet */
317 memcpy(mac_header_data
, mac_header_data
+ ETH_ALEN
, ETH_ALEN
);
318 /* Fill the source mac with nic's source mac */
319 memcpy(mac_header_data
+ ETH_ALEN
, nic
->src_mac_addr
, ETH_ALEN
);
321 /* Alloc skb and reserve align */
322 skb_out
= dev_alloc_skb(skb_in
->len
);
325 skb_reserve(skb_out
, NET_IP_ALIGN
);
327 memcpy(skb_put(skb_out
, mac_header_len
), mac_header_data
,
329 memcpy(skb_put(skb_out
, sizeof(struct ipv6hdr
)), &ipv6_out
,
330 sizeof(struct ipv6hdr
));
331 memcpy(skb_put(skb_out
, sizeof(struct icmp6hdr
)), &icmp6_out
,
332 sizeof(struct icmp6hdr
));
333 memcpy(skb_put(skb_out
, sizeof(struct neighbour_advertisement
)), &na
,
334 sizeof(struct neighbour_advertisement
));
336 skb_out
->protocol
= ((struct ethhdr
*)mac_header_data
)->h_proto
;
337 skb_out
->dev
= skb_in
->dev
;
338 skb_reset_mac_header(skb_out
);
339 skb_pull(skb_out
, ETH_HLEN
);
341 gdm_lte_rx(skb_out
, nic
, nic_type
);
346 static s32
gdm_lte_tx_nic_type(struct net_device
*dev
, struct sk_buff
*skb
)
348 struct nic
*nic
= netdev_priv(dev
);
350 struct vlan_ethhdr
*vlan_eth
;
352 struct ipv6hdr
*ipv6
;
357 /* NIC TYPE is based on the nic_id of this net_device */
358 nic_type
= 0x00000010 | nic
->nic_id
;
360 /* Get ethernet protocol */
361 eth
= (struct ethhdr
*)skb
->data
;
362 if (ntohs(eth
->h_proto
) == ETH_P_8021Q
) {
363 vlan_eth
= (struct vlan_ethhdr
*)skb
->data
;
364 mac_proto
= ntohs(vlan_eth
->h_vlan_encapsulated_proto
);
365 network_data
= skb
->data
+ VLAN_ETH_HLEN
;
366 nic_type
|= NIC_TYPE_F_VLAN
;
368 mac_proto
= ntohs(eth
->h_proto
);
369 network_data
= skb
->data
+ ETH_HLEN
;
372 /* Process packet for nic type */
375 nic_type
|= NIC_TYPE_ARP
;
378 nic_type
|= NIC_TYPE_F_IPV4
;
379 ip
= (struct iphdr
*)network_data
;
382 if (ip
->protocol
== IPPROTO_UDP
) {
383 struct udphdr
*udp
= (struct udphdr
*)
384 (network_data
+ sizeof(struct iphdr
));
385 if (ntohs(udp
->dest
) == 67 || ntohs(udp
->dest
) == 68)
386 nic_type
|= NIC_TYPE_F_DHCP
;
390 nic_type
|= NIC_TYPE_F_IPV6
;
391 ipv6
= (struct ipv6hdr
*)network_data
;
393 if (ipv6
->nexthdr
== IPPROTO_ICMPV6
) /* Check NDP request */ {
394 struct icmp6hdr
*icmp6
= (struct icmp6hdr
*)
395 (network_data
+ sizeof(struct ipv6hdr
));
396 if (icmp6
->icmp6_type
== NDISC_NEIGHBOUR_SOLICITATION
)
397 nic_type
|= NIC_TYPE_ICMPV6
;
398 } else if (ipv6
->nexthdr
== IPPROTO_UDP
) /* Check DHCPv6 */ {
399 struct udphdr
*udp
= (struct udphdr
*)
400 (network_data
+ sizeof(struct ipv6hdr
));
401 if (ntohs(udp
->dest
) == 546 || ntohs(udp
->dest
) == 547)
402 nic_type
|= NIC_TYPE_F_DHCP
;
412 static int gdm_lte_tx(struct sk_buff
*skb
, struct net_device
*dev
)
414 struct nic
*nic
= netdev_priv(dev
);
421 nic_type
= gdm_lte_tx_nic_type(dev
, skb
);
423 netdev_err(dev
, "tx - invalid nic_type\n");
427 if (nic_type
& NIC_TYPE_ARP
) {
428 if (gdm_lte_emulate_arp(skb
, nic_type
) == 0) {
434 if (nic_type
& NIC_TYPE_ICMPV6
) {
435 if (gdm_lte_emulate_ndp(skb
, nic_type
) == 0) {
442 * Need byte shift (that is, remove VLAN tag) if there is one
443 * For the case of ARP, this breaks the offset as vlan_ethhdr+4
444 * is treated as ethhdr However, it shouldn't be a problem as
445 * the response starts from arp_hdr and ethhdr is created by this
446 * driver based on the NIC mac
448 if (nic_type
& NIC_TYPE_F_VLAN
) {
449 struct vlan_ethhdr
*vlan_eth
= (struct vlan_ethhdr
*)skb
->data
;
450 nic
->vlan_id
= ntohs(vlan_eth
->h_vlan_TCI
) & VLAN_VID_MASK
;
451 data_buf
= skb
->data
+ (VLAN_ETH_HLEN
- ETH_HLEN
);
452 data_len
= skb
->len
- (VLAN_ETH_HLEN
- ETH_HLEN
);
455 data_buf
= skb
->data
;
459 /* If it is a ICMPV6 packet, clear all the other bits :
460 * for backward compatibility with the firmware
462 if (nic_type
& NIC_TYPE_ICMPV6
)
463 nic_type
= NIC_TYPE_ICMPV6
;
465 /* If it is not a dhcp packet, clear all the flag bits :
466 * original NIC, otherwise the special flag (IPVX | DHCP)
468 if (!(nic_type
& NIC_TYPE_F_DHCP
))
469 nic_type
&= NIC_TYPE_MASK
;
471 ret
= sscanf(dev
->name
, "lte%d", &idx
);
477 ret
= nic
->phy_dev
->send_sdu_func(nic
->phy_dev
->priv_dev
,
479 nic
->pdn_table
.dft_eps_id
, 0,
480 tx_complete
, nic
, idx
,
483 if (ret
== TX_NO_BUFFER
|| ret
== TX_NO_SPC
) {
484 netif_stop_queue(dev
);
485 if (ret
== TX_NO_BUFFER
)
489 } else if (ret
== TX_NO_DEV
) {
493 /* Updates tx stats */
495 nic
->stats
.tx_dropped
++;
497 nic
->stats
.tx_packets
++;
498 nic
->stats
.tx_bytes
+= data_len
;
505 static struct net_device_stats
*gdm_lte_stats(struct net_device
*dev
)
507 struct nic
*nic
= netdev_priv(dev
);
511 static int gdm_lte_event_send(struct net_device
*dev
, char *buf
, int len
)
513 struct nic
*nic
= netdev_priv(dev
);
514 struct hci_packet
*hci
= (struct hci_packet
*)buf
;
518 ret
= sscanf(dev
->name
, "lte%d", &idx
);
522 return netlink_send(lte_event
.sock
, idx
, 0, buf
,
524 nic
->phy_dev
->get_endian(
525 nic
->phy_dev
->priv_dev
), hci
->len
)
529 static void gdm_lte_event_rcv(struct net_device
*dev
, u16 type
,
532 struct nic
*nic
= netdev_priv(dev
);
534 nic
->phy_dev
->send_hci_func(nic
->phy_dev
->priv_dev
, msg
, len
, NULL
,
538 int gdm_lte_event_init(void)
540 if (lte_event
.ref_cnt
== 0)
541 lte_event
.sock
= netlink_init(NETLINK_LTE
, gdm_lte_event_rcv
);
543 if (lte_event
.sock
) {
548 pr_err("event init failed\n");
552 void gdm_lte_event_exit(void)
554 if (lte_event
.sock
&& --lte_event
.ref_cnt
== 0) {
555 netlink_exit(lte_event
.sock
);
556 lte_event
.sock
= NULL
;
560 static u8
find_dev_index(u32 nic_type
)
564 index
= (u8
)(nic_type
& 0x0000000f);
565 if (index
> MAX_NIC_TYPE
)
571 static void gdm_lte_netif_rx(struct net_device
*dev
, char *buf
,
572 int len
, int flagged_nic_type
)
578 struct vlan_ethhdr vlan_eth
;
579 void *mac_header_data
;
583 nic_type
= flagged_nic_type
& NIC_TYPE_MASK
;
584 nic
= netdev_priv(dev
);
586 if (flagged_nic_type
& NIC_TYPE_F_DHCP
) {
587 /* Change the destination mac address
588 * with the one requested the IP
590 if (flagged_nic_type
& NIC_TYPE_F_IPV4
) {
592 u8 op
; /* BOOTREQUEST or BOOTREPLY */
593 u8 htype
; /* hardware address type.
596 u8 hlen
; /* hardware address length */
597 u8 hops
; /* used by relay agents only */
598 u32 xid
; /* unique id */
599 u16 secs
; /* elapsed since client began
600 * acquisition/renewal
602 u16 flags
; /* only one flag so far: */
603 #define BROADCAST_FLAG 0x8000
604 /* "I need broadcast replies" */
605 u32 ciaddr
; /* client IP (if client is in
606 * BOUND, RENEW or REBINDING state)
608 u32 yiaddr
; /* 'your' (client) IP address */
609 /* IP address of next server to use in
610 * bootstrap, returned in DHCPOFFER,
614 u32 gateway_nip
; /* relay agent IP address */
615 u8 chaddr
[16]; /* link-layer client hardware
618 u8 sname
[64]; /* server host name (ASCIZ) */
619 u8 file
[128]; /* boot file name (ASCIZ) */
620 u32 cookie
; /* fixed first four option
621 * bytes (99,130,83,99 dec)
624 void *addr
= buf
+ sizeof(struct iphdr
) +
625 sizeof(struct udphdr
) +
626 offsetof(struct dhcp_packet
, chaddr
);
627 memcpy(nic
->dest_mac_addr
, addr
, ETH_ALEN
);
631 if (nic
->vlan_id
> 0) {
632 mac_header_data
= (void *)&vlan_eth
;
633 mac_header_len
= VLAN_ETH_HLEN
;
635 mac_header_data
= (void *)ð
;
636 mac_header_len
= ETH_HLEN
;
639 /* Format the data so that it can be put to skb */
640 memcpy(mac_header_data
, nic
->dest_mac_addr
, ETH_ALEN
);
641 memcpy(mac_header_data
+ ETH_ALEN
, nic
->src_mac_addr
, ETH_ALEN
);
643 vlan_eth
.h_vlan_TCI
= htons(nic
->vlan_id
);
644 vlan_eth
.h_vlan_proto
= htons(ETH_P_8021Q
);
646 if (nic_type
== NIC_TYPE_ARP
) {
647 /* Should be response: Only happens because
648 * there was a request from the host
650 eth
.h_proto
= htons(ETH_P_ARP
);
651 vlan_eth
.h_vlan_encapsulated_proto
= htons(ETH_P_ARP
);
653 ip_version
= buf
[0] >> 4;
654 if (ip_version
== IP_VERSION_4
) {
655 eth
.h_proto
= htons(ETH_P_IP
);
656 vlan_eth
.h_vlan_encapsulated_proto
= htons(ETH_P_IP
);
657 } else if (ip_version
== IP_VERSION_6
) {
658 eth
.h_proto
= htons(ETH_P_IPV6
);
659 vlan_eth
.h_vlan_encapsulated_proto
= htons(ETH_P_IPV6
);
661 netdev_err(dev
, "Unknown IP version %d\n", ip_version
);
666 /* Alloc skb and reserve align */
667 skb
= dev_alloc_skb(len
+ mac_header_len
+ NET_IP_ALIGN
);
670 skb_reserve(skb
, NET_IP_ALIGN
);
672 memcpy(skb_put(skb
, mac_header_len
), mac_header_data
, mac_header_len
);
673 memcpy(skb_put(skb
, len
), buf
, len
);
675 skb
->protocol
= ((struct ethhdr
*)mac_header_data
)->h_proto
;
677 skb_reset_mac_header(skb
);
678 skb_pull(skb
, ETH_HLEN
);
680 gdm_lte_rx(skb
, nic
, nic_type
);
683 static void gdm_lte_multi_sdu_pkt(struct phy_dev
*phy_dev
, char *buf
, int len
)
685 struct net_device
*dev
;
686 struct multi_sdu
*multi_sdu
= (struct multi_sdu
*)buf
;
687 struct sdu
*sdu
= NULL
;
688 u8
*data
= (u8
*)multi_sdu
->data
;
696 hci_len
= gdm_dev16_to_cpu(phy_dev
->get_endian(phy_dev
->priv_dev
),
698 num_packet
= gdm_dev16_to_cpu(phy_dev
->get_endian(phy_dev
->priv_dev
),
699 multi_sdu
->num_packet
);
701 for (i
= 0; i
< num_packet
; i
++) {
702 sdu
= (struct sdu
*)data
;
704 cmd_evt
= gdm_dev16_to_cpu(phy_dev
->
705 get_endian(phy_dev
->priv_dev
), sdu
->cmd_evt
);
706 hci_len
= gdm_dev16_to_cpu(phy_dev
->
707 get_endian(phy_dev
->priv_dev
), sdu
->len
);
708 nic_type
= gdm_dev32_to_cpu(phy_dev
->
709 get_endian(phy_dev
->priv_dev
), sdu
->nic_type
);
711 if (cmd_evt
!= LTE_RX_SDU
) {
712 pr_err("rx sdu wrong hci %04x\n", cmd_evt
);
716 pr_err("rx sdu invalid len %d\n", hci_len
);
720 index
= find_dev_index(nic_type
);
721 if (index
< MAX_NIC_TYPE
) {
722 dev
= phy_dev
->dev
[index
];
723 gdm_lte_netif_rx(dev
, (char *)sdu
->data
,
724 (int)(hci_len
-12), nic_type
);
726 pr_err("rx sdu invalid nic_type :%x\n", nic_type
);
729 data
+= ((hci_len
+3) & 0xfffc) + HCI_HEADER_SIZE
;
733 static void gdm_lte_pdn_table(struct net_device
*dev
, char *buf
, int len
)
735 struct nic
*nic
= netdev_priv(dev
);
736 struct hci_pdn_table_ind
*pdn_table
= (struct hci_pdn_table_ind
*)buf
;
738 if (pdn_table
->activate
) {
739 nic
->pdn_table
.activate
= pdn_table
->activate
;
740 nic
->pdn_table
.dft_eps_id
= gdm_dev32_to_cpu(
741 nic
->phy_dev
->get_endian(
742 nic
->phy_dev
->priv_dev
),
743 pdn_table
->dft_eps_id
);
744 nic
->pdn_table
.nic_type
= gdm_dev32_to_cpu(
745 nic
->phy_dev
->get_endian(
746 nic
->phy_dev
->priv_dev
),
747 pdn_table
->nic_type
);
749 netdev_info(dev
, "pdn activated, nic_type=0x%x\n",
750 nic
->pdn_table
.nic_type
);
752 memset(&nic
->pdn_table
, 0x00, sizeof(struct pdn_table
));
753 netdev_info(dev
, "pdn deactivated\n");
757 static int gdm_lte_receive_pkt(struct phy_dev
*phy_dev
, char *buf
, int len
)
759 struct hci_packet
*hci
= (struct hci_packet
*)buf
;
760 struct hci_pdn_table_ind
*pdn_table
= (struct hci_pdn_table_ind
*)buf
;
762 struct net_device
*dev
;
771 cmd_evt
= gdm_dev16_to_cpu(phy_dev
->get_endian(phy_dev
->priv_dev
),
774 dev
= phy_dev
->dev
[0];
780 sdu
= (struct sdu
*)hci
->data
;
781 nic_type
= gdm_dev32_to_cpu(phy_dev
->
782 get_endian(phy_dev
->priv_dev
), sdu
->nic_type
);
783 index
= find_dev_index(nic_type
);
784 dev
= phy_dev
->dev
[index
];
785 gdm_lte_netif_rx(dev
, hci
->data
, len
, nic_type
);
787 case LTE_RX_MULTI_SDU
:
788 gdm_lte_multi_sdu_pkt(phy_dev
, buf
, len
);
790 case LTE_LINK_ON_OFF_INDICATION
:
791 netdev_info(dev
, "link %s\n",
792 ((struct hci_connect_ind
*)buf
)->connect
795 case LTE_PDN_TABLE_IND
:
796 pdn_table
= (struct hci_pdn_table_ind
*)buf
;
797 nic_type
= gdm_dev32_to_cpu(phy_dev
->
798 get_endian(phy_dev
->priv_dev
),
799 pdn_table
->nic_type
);
800 index
= find_dev_index(nic_type
);
801 dev
= phy_dev
->dev
[index
];
802 gdm_lte_pdn_table(dev
, buf
, len
);
805 ret
= gdm_lte_event_send(dev
, buf
, len
);
812 static int rx_complete(void *arg
, void *data
, int len
, int context
)
814 struct phy_dev
*phy_dev
= (struct phy_dev
*)arg
;
816 return gdm_lte_receive_pkt(phy_dev
, (char *)data
, len
);
819 void start_rx_proc(struct phy_dev
*phy_dev
)
823 for (i
= 0; i
< MAX_RX_SUBMIT_COUNT
; i
++)
824 phy_dev
->rcv_func(phy_dev
->priv_dev
,
825 rx_complete
, phy_dev
, USB_COMPLETE
);
828 static struct net_device_ops gdm_netdev_ops
= {
829 .ndo_open
= gdm_lte_open
,
830 .ndo_stop
= gdm_lte_close
,
831 .ndo_set_config
= gdm_lte_set_config
,
832 .ndo_start_xmit
= gdm_lte_tx
,
833 .ndo_get_stats
= gdm_lte_stats
,
836 static u8 gdm_lte_macaddr
[ETH_ALEN
] = {0x00, 0x0a, 0x3b, 0x00, 0x00, 0x00};
838 static void form_mac_address(u8
*dev_addr
, u8
*nic_src
, u8
*nic_dest
,
839 u8
*mac_address
, u8 index
)
841 /* Form the dev_addr */
843 memcpy(dev_addr
, gdm_lte_macaddr
, ETH_ALEN
);
845 memcpy(dev_addr
, mac_address
, ETH_ALEN
);
847 /* The last byte of the mac address
848 * should be less than or equal to 0xFC
850 dev_addr
[ETH_ALEN
-1] += index
;
852 /* Create random nic src and copy the first
853 * 3 bytes to be the same as dev_addr
855 random_ether_addr(nic_src
);
856 memcpy(nic_src
, dev_addr
, 3);
858 /* Copy the nic_dest from dev_addr*/
859 memcpy(nic_dest
, dev_addr
, ETH_ALEN
);
862 static void validate_mac_address(u8
*mac_address
)
864 /* if zero address or multicast bit set, restore the default value */
865 if (is_zero_ether_addr(mac_address
) || (mac_address
[0] & 0x01)) {
866 pr_err("MAC invalid, restoring default\n");
867 memcpy(mac_address
, gdm_lte_macaddr
, 6);
871 int register_lte_device(struct phy_dev
*phy_dev
,
872 struct device
*dev
, u8
*mac_address
)
875 struct net_device
*net
;
876 char pdn_dev_name
[16];
880 validate_mac_address(mac_address
);
882 for (index
= 0; index
< MAX_NIC_TYPE
; index
++) {
883 /* Create device name lteXpdnX */
884 sprintf(pdn_dev_name
, "lte%%dpdn%d", index
);
886 /* Allocate netdev */
887 net
= alloc_netdev(sizeof(struct nic
), pdn_dev_name
,
888 NET_NAME_UNKNOWN
, ether_setup
);
890 pr_err("alloc_netdev failed\n");
894 net
->netdev_ops
= &gdm_netdev_ops
;
895 net
->flags
&= ~IFF_MULTICAST
;
896 net
->mtu
= DEFAULT_MTU_SIZE
;
898 nic
= netdev_priv(net
);
899 memset(nic
, 0, sizeof(struct nic
));
901 nic
->phy_dev
= phy_dev
;
911 SET_NETDEV_DEV(net
, dev
);
912 SET_NETDEV_DEVTYPE(net
, &wwan_type
);
914 ret
= register_netdev(net
);
918 netif_carrier_on(net
);
920 phy_dev
->dev
[index
] = net
;
926 unregister_lte_device(phy_dev
);
931 void unregister_lte_device(struct phy_dev
*phy_dev
)
933 struct net_device
*net
;
936 for (index
= 0; index
< MAX_NIC_TYPE
; index
++) {
937 net
= phy_dev
->dev
[index
];
941 unregister_netdev(net
);