]>
Commit | Line | Data |
---|---|---|
ceed73a2 SAK |
1 | /* Copyright (c) 2013-2017, The Linux Foundation. All rights reserved. |
2 | * | |
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. | |
6 | * | |
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. | |
11 | * | |
12 | * RMNET Data ingress/egress handler | |
13 | * | |
14 | */ | |
15 | ||
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" | |
23 | ||
24 | #define RMNET_IP_VERSION_4 0x40 | |
25 | #define RMNET_IP_VERSION_6 0x60 | |
26 | ||
27 | /* Helper Functions */ | |
28 | ||
29 | static void rmnet_set_skb_proto(struct sk_buff *skb) | |
30 | { | |
31 | switch (skb->data[0] & 0xF0) { | |
32 | case RMNET_IP_VERSION_4: | |
33 | skb->protocol = htons(ETH_P_IP); | |
34 | break; | |
35 | case RMNET_IP_VERSION_6: | |
36 | skb->protocol = htons(ETH_P_IPV6); | |
37 | break; | |
38 | default: | |
39 | skb->protocol = htons(ETH_P_MAP); | |
40 | break; | |
41 | } | |
42 | } | |
43 | ||
44 | /* Generic handler */ | |
45 | ||
2ffbbf0f | 46 | static void |
d8bbb07a | 47 | rmnet_deliver_skb(struct sk_buff *skb) |
ceed73a2 | 48 | { |
ca32fb03 SAK |
49 | struct rmnet_priv *priv = netdev_priv(skb->dev); |
50 | ||
d8bbb07a SAK |
51 | skb_reset_transport_header(skb); |
52 | skb_reset_network_header(skb); | |
53 | rmnet_vnd_rx_fixup(skb, skb->dev); | |
ceed73a2 | 54 | |
d8bbb07a SAK |
55 | skb->pkt_type = PACKET_HOST; |
56 | skb_set_mac_header(skb, 0); | |
ca32fb03 | 57 | gro_cells_receive(&priv->gro_cells, skb); |
ceed73a2 SAK |
58 | } |
59 | ||
ceed73a2 SAK |
60 | /* MAP handler */ |
61 | ||
2ffbbf0f | 62 | static void |
ceed73a2 | 63 | __rmnet_map_ingress_handler(struct sk_buff *skb, |
b665f4f8 | 64 | struct rmnet_port *port) |
ceed73a2 SAK |
65 | { |
66 | struct rmnet_endpoint *ep; | |
67 | u8 mux_id; | |
68 | u16 len; | |
69 | ||
70 | if (RMNET_MAP_GET_CD_BIT(skb)) { | |
b665f4f8 | 71 | if (port->ingress_data_format |
ceed73a2 | 72 | & RMNET_INGRESS_FORMAT_MAP_COMMANDS) |
b665f4f8 | 73 | return rmnet_map_command(skb, port); |
ceed73a2 | 74 | |
3352e6c4 | 75 | goto free_skb; |
ceed73a2 SAK |
76 | } |
77 | ||
78 | mux_id = RMNET_MAP_GET_MUX_ID(skb); | |
79 | len = RMNET_MAP_GET_LENGTH(skb) - RMNET_MAP_GET_PAD(skb); | |
80 | ||
3352e6c4 SAK |
81 | if (mux_id >= RMNET_MAX_LOGICAL_EP) |
82 | goto free_skb; | |
ceed73a2 | 83 | |
3352e6c4 SAK |
84 | ep = rmnet_get_endpoint(port, mux_id); |
85 | if (!ep) | |
86 | goto free_skb; | |
ceed73a2 | 87 | |
85355d77 | 88 | skb->dev = ep->egress_dev; |
ceed73a2 SAK |
89 | |
90 | /* Subtract MAP header */ | |
91 | skb_pull(skb, sizeof(struct rmnet_map_header)); | |
92 | skb_trim(skb, len); | |
93 | rmnet_set_skb_proto(skb); | |
2ffbbf0f SAK |
94 | rmnet_deliver_skb(skb); |
95 | return; | |
3352e6c4 SAK |
96 | |
97 | free_skb: | |
98 | kfree_skb(skb); | |
ceed73a2 SAK |
99 | } |
100 | ||
2ffbbf0f | 101 | static void |
ceed73a2 | 102 | rmnet_map_ingress_handler(struct sk_buff *skb, |
b665f4f8 | 103 | struct rmnet_port *port) |
ceed73a2 SAK |
104 | { |
105 | struct sk_buff *skbn; | |
ceed73a2 | 106 | |
b665f4f8 SAK |
107 | if (port->ingress_data_format & RMNET_INGRESS_FORMAT_DEAGGREGATION) { |
108 | while ((skbn = rmnet_map_deaggregate(skb)) != NULL) | |
109 | __rmnet_map_ingress_handler(skbn, port); | |
ceed73a2 SAK |
110 | |
111 | consume_skb(skb); | |
ceed73a2 | 112 | } else { |
2ffbbf0f | 113 | __rmnet_map_ingress_handler(skb, port); |
ceed73a2 | 114 | } |
ceed73a2 SAK |
115 | } |
116 | ||
117 | static int rmnet_map_egress_handler(struct sk_buff *skb, | |
56470c92 | 118 | struct rmnet_port *port, u8 mux_id, |
ceed73a2 SAK |
119 | struct net_device *orig_dev) |
120 | { | |
121 | int required_headroom, additional_header_len; | |
122 | struct rmnet_map_header *map_header; | |
123 | ||
124 | additional_header_len = 0; | |
125 | required_headroom = sizeof(struct rmnet_map_header); | |
126 | ||
127 | if (skb_headroom(skb) < required_headroom) { | |
128 | if (pskb_expand_head(skb, required_headroom, 0, GFP_KERNEL)) | |
c20a5487 | 129 | goto fail; |
ceed73a2 SAK |
130 | } |
131 | ||
132 | map_header = rmnet_map_add_map_header(skb, additional_header_len, 0); | |
133 | if (!map_header) | |
c20a5487 | 134 | goto fail; |
ceed73a2 | 135 | |
b665f4f8 | 136 | if (port->egress_data_format & RMNET_EGRESS_FORMAT_MUXING) { |
56470c92 | 137 | if (mux_id == 0xff) |
ceed73a2 SAK |
138 | map_header->mux_id = 0; |
139 | else | |
56470c92 | 140 | map_header->mux_id = mux_id; |
ceed73a2 SAK |
141 | } |
142 | ||
143 | skb->protocol = htons(ETH_P_MAP); | |
144 | ||
145 | return RMNET_MAP_SUCCESS; | |
c20a5487 SAK |
146 | |
147 | fail: | |
148 | kfree_skb(skb); | |
149 | return RMNET_MAP_CONSUMED; | |
ceed73a2 SAK |
150 | } |
151 | ||
2ffbbf0f | 152 | static void |
60d58f97 SAK |
153 | rmnet_bridge_handler(struct sk_buff *skb, struct net_device *bridge_dev) |
154 | { | |
155 | if (bridge_dev) { | |
156 | skb->dev = bridge_dev; | |
157 | dev_queue_xmit(skb); | |
158 | } | |
60d58f97 SAK |
159 | } |
160 | ||
ceed73a2 SAK |
161 | /* Ingress / Egress Entry Points */ |
162 | ||
163 | /* Processes packet as per ingress data format for receiving device. Logical | |
164 | * endpoint is determined from packet inspection. Packet is then sent to the | |
165 | * egress device listed in the logical endpoint configuration. | |
166 | */ | |
167 | rx_handler_result_t rmnet_rx_handler(struct sk_buff **pskb) | |
168 | { | |
ceed73a2 | 169 | struct sk_buff *skb = *pskb; |
60d58f97 | 170 | struct rmnet_port *port; |
ceed73a2 | 171 | struct net_device *dev; |
ceed73a2 SAK |
172 | |
173 | if (!skb) | |
2ffbbf0f | 174 | goto done; |
ceed73a2 SAK |
175 | |
176 | dev = skb->dev; | |
b665f4f8 | 177 | port = rmnet_get_port(dev); |
ceed73a2 | 178 | |
60d58f97 SAK |
179 | switch (port->rmnet_mode) { |
180 | case RMNET_EPMODE_VND: | |
181 | if (port->ingress_data_format & RMNET_INGRESS_FORMAT_MAP) | |
2ffbbf0f | 182 | rmnet_map_ingress_handler(skb, port); |
60d58f97 SAK |
183 | break; |
184 | case RMNET_EPMODE_BRIDGE: | |
2ffbbf0f | 185 | rmnet_bridge_handler(skb, port->bridge_ep); |
60d58f97 SAK |
186 | break; |
187 | } | |
ceed73a2 | 188 | |
2ffbbf0f SAK |
189 | done: |
190 | return RX_HANDLER_CONSUMED; | |
ceed73a2 SAK |
191 | } |
192 | ||
193 | /* Modifies packet as per logical endpoint configuration and egress data format | |
194 | * for egress device configured in logical endpoint. Packet is then transmitted | |
195 | * on the egress device. | |
196 | */ | |
56470c92 | 197 | void rmnet_egress_handler(struct sk_buff *skb) |
ceed73a2 | 198 | { |
ceed73a2 | 199 | struct net_device *orig_dev; |
b665f4f8 | 200 | struct rmnet_port *port; |
56470c92 SAK |
201 | struct rmnet_priv *priv; |
202 | u8 mux_id; | |
ceed73a2 SAK |
203 | |
204 | orig_dev = skb->dev; | |
56470c92 SAK |
205 | priv = netdev_priv(orig_dev); |
206 | skb->dev = priv->real_dev; | |
207 | mux_id = priv->mux_id; | |
ceed73a2 | 208 | |
b665f4f8 SAK |
209 | port = rmnet_get_port(skb->dev); |
210 | if (!port) { | |
ceed73a2 SAK |
211 | kfree_skb(skb); |
212 | return; | |
213 | } | |
214 | ||
b665f4f8 | 215 | if (port->egress_data_format & RMNET_EGRESS_FORMAT_MAP) { |
56470c92 | 216 | switch (rmnet_map_egress_handler(skb, port, mux_id, orig_dev)) { |
ceed73a2 SAK |
217 | case RMNET_MAP_CONSUMED: |
218 | return; | |
219 | ||
220 | case RMNET_MAP_SUCCESS: | |
221 | break; | |
222 | ||
223 | default: | |
224 | kfree_skb(skb); | |
225 | return; | |
226 | } | |
227 | } | |
228 | ||
91489632 | 229 | rmnet_vnd_tx_fixup(skb, orig_dev); |
ceed73a2 SAK |
230 | |
231 | dev_queue_xmit(skb); | |
232 | } |