]>
Commit | Line | Data |
---|---|---|
2874c5fd | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
d4026123 MK |
2 | /* |
3 | * USB network interface driver for Samsung Kalmia based LTE USB modem like the | |
4 | * Samsung GT-B3730 and GT-B3710. | |
5 | * | |
6 | * Copyright (C) 2011 Marius Bjoernstad Kotsbak <marius@kotsbak.com> | |
7 | * | |
8 | * Sponsored by Quicklink Video Distribution Services Ltd. | |
9 | * | |
10 | * Based on the cdc_eem module. | |
d4026123 MK |
11 | */ |
12 | ||
13 | #include <linux/module.h> | |
d4026123 MK |
14 | #include <linux/netdevice.h> |
15 | #include <linux/etherdevice.h> | |
16 | #include <linux/ctype.h> | |
17 | #include <linux/ethtool.h> | |
18 | #include <linux/workqueue.h> | |
19 | #include <linux/mii.h> | |
20 | #include <linux/usb.h> | |
21 | #include <linux/crc32.h> | |
22 | #include <linux/usb/cdc.h> | |
23 | #include <linux/usb/usbnet.h> | |
24 | #include <linux/gfp.h> | |
25 | ||
26 | /* | |
27 | * The Samsung Kalmia based LTE USB modems have a CDC ACM port for modem control | |
28 | * handled by the "option" module and an ethernet data port handled by this | |
29 | * module. | |
30 | * | |
31 | * The stick must first be switched into modem mode by usb_modeswitch | |
32 | * or similar tool. Then the modem gets sent two initialization packets by | |
33 | * this module, which gives the MAC address of the device. User space can then | |
34 | * connect the modem using AT commands through the ACM port and then use | |
35 | * DHCP on the network interface exposed by this module. Network packets are | |
36 | * sent to and from the modem in a proprietary format discovered after watching | |
37 | * the behavior of the windows driver for the modem. | |
38 | * | |
39 | * More information about the use of the modem is available in usb_modeswitch | |
40 | * forum and the project page: | |
41 | * | |
42 | * http://www.draisberghof.de/usb_modeswitch/bb/viewtopic.php?t=465 | |
43 | * https://github.com/mkotsbak/Samsung-GT-B3730-linux-driver | |
44 | */ | |
45 | ||
46 | /* #define DEBUG */ | |
47 | /* #define VERBOSE */ | |
48 | ||
49 | #define KALMIA_HEADER_LENGTH 6 | |
50 | #define KALMIA_ALIGN_SIZE 4 | |
51 | #define KALMIA_USB_TIMEOUT 10000 | |
52 | ||
53 | /*-------------------------------------------------------------------------*/ | |
54 | ||
55 | static int | |
56 | kalmia_send_init_packet(struct usbnet *dev, u8 *init_msg, u8 init_msg_len, | |
57 | u8 *buffer, u8 expected_len) | |
58 | { | |
59 | int act_len; | |
60 | int status; | |
61 | ||
62 | netdev_dbg(dev->net, "Sending init packet"); | |
63 | ||
64 | status = usb_bulk_msg(dev->udev, usb_sndbulkpipe(dev->udev, 0x02), | |
65 | init_msg, init_msg_len, &act_len, KALMIA_USB_TIMEOUT); | |
66 | if (status != 0) { | |
67 | netdev_err(dev->net, | |
68 | "Error sending init packet. Status %i, length %i\n", | |
69 | status, act_len); | |
70 | return status; | |
71 | } | |
72 | else if (act_len != init_msg_len) { | |
73 | netdev_err(dev->net, | |
74 | "Did not send all of init packet. Bytes sent: %i", | |
75 | act_len); | |
76 | } | |
77 | else { | |
78 | netdev_dbg(dev->net, "Successfully sent init packet."); | |
79 | } | |
80 | ||
81 | status = usb_bulk_msg(dev->udev, usb_rcvbulkpipe(dev->udev, 0x81), | |
82 | buffer, expected_len, &act_len, KALMIA_USB_TIMEOUT); | |
83 | ||
84 | if (status != 0) | |
85 | netdev_err(dev->net, | |
86 | "Error receiving init result. Status %i, length %i\n", | |
87 | status, act_len); | |
88 | else if (act_len != expected_len) | |
89 | netdev_err(dev->net, "Unexpected init result length: %i\n", | |
90 | act_len); | |
91 | ||
92 | return status; | |
93 | } | |
94 | ||
95 | static int | |
96 | kalmia_init_and_get_ethernet_addr(struct usbnet *dev, u8 *ethernet_addr) | |
97 | { | |
bd0d7aa6 | 98 | static const char init_msg_1[] = |
d4026123 MK |
99 | { 0x57, 0x50, 0x04, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, |
100 | 0x00, 0x00 }; | |
bd0d7aa6 | 101 | static const char init_msg_2[] = |
d4026123 MK |
102 | { 0x57, 0x50, 0x04, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0xf4, |
103 | 0x00, 0x00 }; | |
bd0d7aa6 | 104 | static const int buflen = 28; |
7cdfa4a3 | 105 | char *usb_buf; |
d4026123 MK |
106 | int status; |
107 | ||
7cdfa4a3 MK |
108 | usb_buf = kmalloc(buflen, GFP_DMA | GFP_KERNEL); |
109 | if (!usb_buf) | |
110 | return -ENOMEM; | |
111 | ||
112 | memcpy(usb_buf, init_msg_1, 12); | |
b72c8a7e CIK |
113 | status = kalmia_send_init_packet(dev, usb_buf, ARRAY_SIZE(init_msg_1), |
114 | usb_buf, 24); | |
d4026123 MK |
115 | if (status != 0) |
116 | return status; | |
117 | ||
7cdfa4a3 | 118 | memcpy(usb_buf, init_msg_2, 12); |
b72c8a7e CIK |
119 | status = kalmia_send_init_packet(dev, usb_buf, ARRAY_SIZE(init_msg_2), |
120 | usb_buf, 28); | |
d4026123 MK |
121 | if (status != 0) |
122 | return status; | |
123 | ||
7cdfa4a3 | 124 | memcpy(ethernet_addr, usb_buf + 10, ETH_ALEN); |
d4026123 | 125 | |
7cdfa4a3 | 126 | kfree(usb_buf); |
d4026123 MK |
127 | return status; |
128 | } | |
129 | ||
130 | static int | |
131 | kalmia_bind(struct usbnet *dev, struct usb_interface *intf) | |
132 | { | |
5c18e80b | 133 | int status; |
d4026123 MK |
134 | u8 ethernet_addr[ETH_ALEN]; |
135 | ||
136 | /* Don't bind to AT command interface */ | |
137 | if (intf->cur_altsetting->desc.bInterfaceClass != USB_CLASS_VENDOR_SPEC) | |
138 | return -EINVAL; | |
139 | ||
140 | dev->in = usb_rcvbulkpipe(dev->udev, 0x81 & USB_ENDPOINT_NUMBER_MASK); | |
141 | dev->out = usb_sndbulkpipe(dev->udev, 0x02 & USB_ENDPOINT_NUMBER_MASK); | |
142 | dev->status = NULL; | |
143 | ||
144 | dev->net->hard_header_len += KALMIA_HEADER_LENGTH; | |
145 | dev->hard_mtu = 1400; | |
146 | dev->rx_urb_size = dev->hard_mtu * 10; // Found as optimal after testing | |
147 | ||
148 | status = kalmia_init_and_get_ethernet_addr(dev, ethernet_addr); | |
4f06717f | 149 | if (status) |
d4026123 | 150 | return status; |
d4026123 MK |
151 | |
152 | memcpy(dev->net->dev_addr, ethernet_addr, ETH_ALEN); | |
d4026123 MK |
153 | |
154 | return status; | |
155 | } | |
156 | ||
157 | static struct sk_buff * | |
158 | kalmia_tx_fixup(struct usbnet *dev, struct sk_buff *skb, gfp_t flags) | |
159 | { | |
160 | struct sk_buff *skb2 = NULL; | |
161 | u16 content_len; | |
162 | unsigned char *header_start; | |
163 | unsigned char ether_type_1, ether_type_2; | |
164 | u8 remainder, padlen = 0; | |
165 | ||
166 | if (!skb_cloned(skb)) { | |
167 | int headroom = skb_headroom(skb); | |
168 | int tailroom = skb_tailroom(skb); | |
169 | ||
170 | if ((tailroom >= KALMIA_ALIGN_SIZE) && (headroom | |
171 | >= KALMIA_HEADER_LENGTH)) | |
172 | goto done; | |
173 | ||
174 | if ((headroom + tailroom) > (KALMIA_HEADER_LENGTH | |
175 | + KALMIA_ALIGN_SIZE)) { | |
176 | skb->data = memmove(skb->head + KALMIA_HEADER_LENGTH, | |
177 | skb->data, skb->len); | |
178 | skb_set_tail_pointer(skb, skb->len); | |
179 | goto done; | |
180 | } | |
181 | } | |
182 | ||
183 | skb2 = skb_copy_expand(skb, KALMIA_HEADER_LENGTH, | |
184 | KALMIA_ALIGN_SIZE, flags); | |
185 | if (!skb2) | |
186 | return NULL; | |
187 | ||
188 | dev_kfree_skb_any(skb); | |
189 | skb = skb2; | |
190 | ||
7cdfa4a3 MK |
191 | done: |
192 | header_start = skb_push(skb, KALMIA_HEADER_LENGTH); | |
d4026123 MK |
193 | ether_type_1 = header_start[KALMIA_HEADER_LENGTH + 12]; |
194 | ether_type_2 = header_start[KALMIA_HEADER_LENGTH + 13]; | |
195 | ||
196 | netdev_dbg(dev->net, "Sending etherType: %02x%02x", ether_type_1, | |
197 | ether_type_2); | |
198 | ||
199 | /* According to empiric data for data packages */ | |
200 | header_start[0] = 0x57; | |
201 | header_start[1] = 0x44; | |
202 | content_len = skb->len - KALMIA_HEADER_LENGTH; | |
d4026123 | 203 | |
7cdfa4a3 | 204 | put_unaligned_le16(content_len, &header_start[2]); |
d4026123 MK |
205 | header_start[4] = ether_type_1; |
206 | header_start[5] = ether_type_2; | |
207 | ||
208 | /* Align to 4 bytes by padding with zeros */ | |
209 | remainder = skb->len % KALMIA_ALIGN_SIZE; | |
210 | if (remainder > 0) { | |
211 | padlen = KALMIA_ALIGN_SIZE - remainder; | |
b080db58 | 212 | skb_put_zero(skb, padlen); |
d4026123 MK |
213 | } |
214 | ||
cbb963de AS |
215 | netdev_dbg(dev->net, |
216 | "Sending package with length %i and padding %i. Header: %6phC.", | |
217 | content_len, padlen, header_start); | |
d4026123 MK |
218 | |
219 | return skb; | |
220 | } | |
221 | ||
222 | static int | |
223 | kalmia_rx_fixup(struct usbnet *dev, struct sk_buff *skb) | |
224 | { | |
225 | /* | |
226 | * Our task here is to strip off framing, leaving skb with one | |
227 | * data frame for the usbnet framework code to process. | |
228 | */ | |
bd0d7aa6 | 229 | static const u8 HEADER_END_OF_USB_PACKET[] = |
d4026123 | 230 | { 0x57, 0x5a, 0x00, 0x00, 0x08, 0x00 }; |
bd0d7aa6 | 231 | static const u8 EXPECTED_UNKNOWN_HEADER_1[] = |
d4026123 | 232 | { 0x57, 0x43, 0x1e, 0x00, 0x15, 0x02 }; |
bd0d7aa6 | 233 | static const u8 EXPECTED_UNKNOWN_HEADER_2[] = |
d4026123 | 234 | { 0x57, 0x50, 0x0e, 0x00, 0x00, 0x00 }; |
7cdfa4a3 | 235 | int i = 0; |
d4026123 MK |
236 | |
237 | /* incomplete header? */ | |
238 | if (skb->len < KALMIA_HEADER_LENGTH) | |
239 | return 0; | |
240 | ||
241 | do { | |
242 | struct sk_buff *skb2 = NULL; | |
243 | u8 *header_start; | |
244 | u16 usb_packet_length, ether_packet_length; | |
245 | int is_last; | |
246 | ||
247 | header_start = skb->data; | |
248 | ||
249 | if (unlikely(header_start[0] != 0x57 || header_start[1] != 0x44)) { | |
250 | if (!memcmp(header_start, EXPECTED_UNKNOWN_HEADER_1, | |
251 | sizeof(EXPECTED_UNKNOWN_HEADER_1)) || !memcmp( | |
252 | header_start, EXPECTED_UNKNOWN_HEADER_2, | |
253 | sizeof(EXPECTED_UNKNOWN_HEADER_2))) { | |
cbb963de AS |
254 | netdev_dbg(dev->net, |
255 | "Received expected unknown frame header: %6phC. Package length: %i\n", | |
256 | header_start, | |
d4026123 MK |
257 | skb->len - KALMIA_HEADER_LENGTH); |
258 | } | |
259 | else { | |
cbb963de AS |
260 | netdev_err(dev->net, |
261 | "Received unknown frame header: %6phC. Package length: %i\n", | |
262 | header_start, | |
d4026123 MK |
263 | skb->len - KALMIA_HEADER_LENGTH); |
264 | return 0; | |
265 | } | |
266 | } | |
267 | else | |
cbb963de AS |
268 | netdev_dbg(dev->net, |
269 | "Received header: %6phC. Package length: %i\n", | |
270 | header_start, skb->len - KALMIA_HEADER_LENGTH); | |
d4026123 MK |
271 | |
272 | /* subtract start header and end header */ | |
273 | usb_packet_length = skb->len - (2 * KALMIA_HEADER_LENGTH); | |
7cdfa4a3 | 274 | ether_packet_length = get_unaligned_le16(&header_start[2]); |
d4026123 MK |
275 | skb_pull(skb, KALMIA_HEADER_LENGTH); |
276 | ||
277 | /* Some small packets misses end marker */ | |
278 | if (usb_packet_length < ether_packet_length) { | |
279 | ether_packet_length = usb_packet_length | |
280 | + KALMIA_HEADER_LENGTH; | |
281 | is_last = true; | |
282 | } | |
283 | else { | |
284 | netdev_dbg(dev->net, "Correct package length #%i", i | |
285 | + 1); | |
286 | ||
287 | is_last = (memcmp(skb->data + ether_packet_length, | |
288 | HEADER_END_OF_USB_PACKET, | |
289 | sizeof(HEADER_END_OF_USB_PACKET)) == 0); | |
290 | if (!is_last) { | |
291 | header_start = skb->data + ether_packet_length; | |
cbb963de AS |
292 | netdev_dbg(dev->net, |
293 | "End header: %6phC. Package length: %i\n", | |
294 | header_start, | |
d4026123 MK |
295 | skb->len - KALMIA_HEADER_LENGTH); |
296 | } | |
297 | } | |
298 | ||
299 | if (is_last) { | |
300 | skb2 = skb; | |
301 | } | |
302 | else { | |
303 | skb2 = skb_clone(skb, GFP_ATOMIC); | |
304 | if (unlikely(!skb2)) | |
305 | return 0; | |
306 | } | |
307 | ||
308 | skb_trim(skb2, ether_packet_length); | |
309 | ||
310 | if (is_last) { | |
311 | return 1; | |
312 | } | |
313 | else { | |
314 | usbnet_skb_return(dev, skb2); | |
315 | skb_pull(skb, ether_packet_length); | |
316 | } | |
317 | ||
318 | i++; | |
319 | } | |
320 | while (skb->len); | |
321 | ||
322 | return 1; | |
323 | } | |
324 | ||
325 | static const struct driver_info kalmia_info = { | |
326 | .description = "Samsung Kalmia LTE USB dongle", | |
327 | .flags = FLAG_WWAN, | |
328 | .bind = kalmia_bind, | |
329 | .rx_fixup = kalmia_rx_fixup, | |
330 | .tx_fixup = kalmia_tx_fixup | |
331 | }; | |
332 | ||
333 | /*-------------------------------------------------------------------------*/ | |
334 | ||
335 | static const struct usb_device_id products[] = { | |
336 | /* The unswitched USB ID, to get the module auto loaded: */ | |
337 | { USB_DEVICE(0x04e8, 0x689a) }, | |
08a7e621 | 338 | /* The stick switched into modem (by e.g. usb_modeswitch): */ |
d4026123 MK |
339 | { USB_DEVICE(0x04e8, 0x6889), |
340 | .driver_info = (unsigned long) &kalmia_info, }, | |
341 | { /* EMPTY == end of list */} }; | |
342 | MODULE_DEVICE_TABLE( usb, products); | |
343 | ||
344 | static struct usb_driver kalmia_driver = { | |
345 | .name = "kalmia", | |
346 | .id_table = products, | |
347 | .probe = usbnet_probe, | |
348 | .disconnect = usbnet_disconnect, | |
349 | .suspend = usbnet_suspend, | |
e1f12eb6 SS |
350 | .resume = usbnet_resume, |
351 | .disable_hub_initiated_lpm = 1, | |
d4026123 MK |
352 | }; |
353 | ||
d632eb1b | 354 | module_usb_driver(kalmia_driver); |
d4026123 MK |
355 | |
356 | MODULE_AUTHOR("Marius Bjoernstad Kotsbak <marius@kotsbak.com>"); | |
357 | MODULE_DESCRIPTION("Samsung Kalmia USB network driver"); | |
358 | MODULE_LICENSE("GPL"); |