1 /* Copyright (c) 2013-2017, The Linux Foundation. All rights reserved.
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License version 2 and
5 * only version 2 as published by the Free Software Foundation.
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
12 * RMNET Data ingress/egress handler
16 #include <linux/netdevice.h>
17 #include <linux/netdev_features.h>
18 #include "rmnet_private.h"
19 #include "rmnet_config.h"
20 #include "rmnet_vnd.h"
21 #include "rmnet_map.h"
22 #include "rmnet_handlers.h"
24 #define RMNET_IP_VERSION_4 0x40
25 #define RMNET_IP_VERSION_6 0x60
27 /* Helper Functions */
29 static void rmnet_set_skb_proto(struct sk_buff *skb)
31 switch (skb->data[0] & 0xF0) {
32 case RMNET_IP_VERSION_4:
33 skb->protocol = htons(ETH_P_IP);
35 case RMNET_IP_VERSION_6:
36 skb->protocol = htons(ETH_P_IPV6);
39 skb->protocol = htons(ETH_P_MAP);
46 static rx_handler_result_t
47 rmnet_bridge_handler(struct sk_buff *skb, struct rmnet_endpoint *ep)
52 rmnet_egress_handler(skb, ep);
54 return RX_HANDLER_CONSUMED;
57 static rx_handler_result_t
58 rmnet_deliver_skb(struct sk_buff *skb, struct rmnet_endpoint *ep)
60 switch (ep->rmnet_mode) {
61 case RMNET_EPMODE_NONE:
62 return RX_HANDLER_PASS;
64 case RMNET_EPMODE_BRIDGE:
65 return rmnet_bridge_handler(skb, ep);
67 case RMNET_EPMODE_VND:
68 skb_reset_transport_header(skb);
69 skb_reset_network_header(skb);
70 rmnet_vnd_rx_fixup(skb, skb->dev);
72 skb->pkt_type = PACKET_HOST;
73 skb_set_mac_header(skb, 0);
74 netif_receive_skb(skb);
75 return RX_HANDLER_CONSUMED;
79 return RX_HANDLER_CONSUMED;
83 static rx_handler_result_t
84 rmnet_ingress_deliver_packet(struct sk_buff *skb,
85 struct rmnet_port *port)
89 return RX_HANDLER_CONSUMED;
92 skb->dev = port->local_ep.egress_dev;
94 return rmnet_deliver_skb(skb, &port->local_ep);
99 static rx_handler_result_t
100 __rmnet_map_ingress_handler(struct sk_buff *skb,
101 struct rmnet_port *port)
103 struct rmnet_endpoint *ep;
107 if (RMNET_MAP_GET_CD_BIT(skb)) {
108 if (port->ingress_data_format
109 & RMNET_INGRESS_FORMAT_MAP_COMMANDS)
110 return rmnet_map_command(skb, port);
113 return RX_HANDLER_CONSUMED;
116 mux_id = RMNET_MAP_GET_MUX_ID(skb);
117 len = RMNET_MAP_GET_LENGTH(skb) - RMNET_MAP_GET_PAD(skb);
119 if (mux_id >= RMNET_MAX_LOGICAL_EP) {
121 return RX_HANDLER_CONSUMED;
124 ep = &port->muxed_ep[mux_id];
126 if (port->ingress_data_format & RMNET_INGRESS_FORMAT_DEMUXING)
127 skb->dev = ep->egress_dev;
129 /* Subtract MAP header */
130 skb_pull(skb, sizeof(struct rmnet_map_header));
132 rmnet_set_skb_proto(skb);
133 return rmnet_deliver_skb(skb, ep);
136 static rx_handler_result_t
137 rmnet_map_ingress_handler(struct sk_buff *skb,
138 struct rmnet_port *port)
140 struct sk_buff *skbn;
143 if (port->ingress_data_format & RMNET_INGRESS_FORMAT_DEAGGREGATION) {
144 while ((skbn = rmnet_map_deaggregate(skb)) != NULL)
145 __rmnet_map_ingress_handler(skbn, port);
148 rc = RX_HANDLER_CONSUMED;
150 rc = __rmnet_map_ingress_handler(skb, port);
156 static int rmnet_map_egress_handler(struct sk_buff *skb,
157 struct rmnet_port *port,
158 struct rmnet_endpoint *ep,
159 struct net_device *orig_dev)
161 int required_headroom, additional_header_len;
162 struct rmnet_map_header *map_header;
164 additional_header_len = 0;
165 required_headroom = sizeof(struct rmnet_map_header);
167 if (skb_headroom(skb) < required_headroom) {
168 if (pskb_expand_head(skb, required_headroom, 0, GFP_KERNEL))
172 map_header = rmnet_map_add_map_header(skb, additional_header_len, 0);
176 if (port->egress_data_format & RMNET_EGRESS_FORMAT_MUXING) {
177 if (ep->mux_id == 0xff)
178 map_header->mux_id = 0;
180 map_header->mux_id = ep->mux_id;
183 skb->protocol = htons(ETH_P_MAP);
185 return RMNET_MAP_SUCCESS;
189 return RMNET_MAP_CONSUMED;
192 /* Ingress / Egress Entry Points */
194 /* Processes packet as per ingress data format for receiving device. Logical
195 * endpoint is determined from packet inspection. Packet is then sent to the
196 * egress device listed in the logical endpoint configuration.
198 rx_handler_result_t rmnet_rx_handler(struct sk_buff **pskb)
200 struct rmnet_port *port;
201 struct sk_buff *skb = *pskb;
202 struct net_device *dev;
206 return RX_HANDLER_CONSUMED;
208 if (skb->pkt_type == PACKET_LOOPBACK)
209 return RX_HANDLER_PASS;
212 port = rmnet_get_port(dev);
214 if (port->ingress_data_format & RMNET_INGRESS_FORMAT_MAP) {
215 rc = rmnet_map_ingress_handler(skb, port);
217 switch (ntohs(skb->protocol)) {
219 if (port->local_ep.rmnet_mode ==
220 RMNET_EPMODE_BRIDGE) {
221 rc = rmnet_ingress_deliver_packet(skb, port);
224 rc = RX_HANDLER_CONSUMED;
230 rc = rmnet_ingress_deliver_packet(skb, port);
234 rc = RX_HANDLER_PASS;
241 /* Modifies packet as per logical endpoint configuration and egress data format
242 * for egress device configured in logical endpoint. Packet is then transmitted
243 * on the egress device.
245 void rmnet_egress_handler(struct sk_buff *skb,
246 struct rmnet_endpoint *ep)
248 struct net_device *orig_dev;
249 struct rmnet_port *port;
252 skb->dev = ep->egress_dev;
254 port = rmnet_get_port(skb->dev);
260 if (port->egress_data_format & RMNET_EGRESS_FORMAT_MAP) {
261 switch (rmnet_map_egress_handler(skb, port, ep, orig_dev)) {
262 case RMNET_MAP_CONSUMED:
265 case RMNET_MAP_SUCCESS:
274 if (ep->rmnet_mode == RMNET_EPMODE_VND)
275 rmnet_vnd_tx_fixup(skb, orig_dev);