359 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * USB network interface driver for Samsung Kalmia based LTE USB modem like the4 * 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.11 */12 13#include <linux/module.h>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 control28 * handled by the "option" module and an ethernet data port handled by this29 * module.30 *31 * The stick must first be switched into modem mode by usb_modeswitch32 * or similar tool. Then the modem gets sent two initialization packets by33 * this module, which gives the MAC address of the device. User space can then34 * connect the modem using AT commands through the ACM port and then use35 * DHCP on the network interface exposed by this module. Network packets are36 * sent to and from the modem in a proprietary format discovered after watching37 * the behavior of the windows driver for the modem.38 *39 * More information about the use of the modem is available in usb_modeswitch40 * forum and the project page:41 *42 * http://www.draisberghof.de/usb_modeswitch/bb/viewtopic.php?t=46543 * https://github.com/mkotsbak/Samsung-GT-B3730-linux-driver44 */45 46/* #define DEBUG */47/* #define VERBOSE */48 49#define KALMIA_HEADER_LENGTH 650#define KALMIA_ALIGN_SIZE 451#define KALMIA_USB_TIMEOUT 1000052 53/*-------------------------------------------------------------------------*/54 55static int56kalmia_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\n",69 status);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\n",87 status);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 95static int96kalmia_init_and_get_ethernet_addr(struct usbnet *dev, u8 *ethernet_addr)97{98 static const char init_msg_1[] =99 { 0x57, 0x50, 0x04, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,100 0x00, 0x00 };101 static const char init_msg_2[] =102 { 0x57, 0x50, 0x04, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0xf4,103 0x00, 0x00 };104 static const int buflen = 28;105 char *usb_buf;106 int status;107 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);113 status = kalmia_send_init_packet(dev, usb_buf, ARRAY_SIZE(init_msg_1),114 usb_buf, 24);115 if (status != 0)116 goto out;117 118 memcpy(usb_buf, init_msg_2, 12);119 status = kalmia_send_init_packet(dev, usb_buf, ARRAY_SIZE(init_msg_2),120 usb_buf, 28);121 if (status != 0)122 goto out;123 124 memcpy(ethernet_addr, usb_buf + 10, ETH_ALEN);125out:126 kfree(usb_buf);127 return status;128}129 130static int131kalmia_bind(struct usbnet *dev, struct usb_interface *intf)132{133 int status;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 testing147 148 status = kalmia_init_and_get_ethernet_addr(dev, ethernet_addr);149 if (status)150 return status;151 152 eth_hw_addr_set(dev->net, ethernet_addr);153 154 return status;155}156 157static struct sk_buff *158kalmia_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) && (headroom171 >= KALMIA_HEADER_LENGTH))172 goto done;173 174 if ((headroom + tailroom) > (KALMIA_HEADER_LENGTH175 + 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 191done:192 header_start = skb_push(skb, KALMIA_HEADER_LENGTH);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;203 204 put_unaligned_le16(content_len, &header_start[2]);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;212 skb_put_zero(skb, padlen);213 }214 215 netdev_dbg(dev->net,216 "Sending package with length %i and padding %i. Header: %6phC.",217 content_len, padlen, header_start);218 219 return skb;220}221 222static int223kalmia_rx_fixup(struct usbnet *dev, struct sk_buff *skb)224{225 /*226 * Our task here is to strip off framing, leaving skb with one227 * data frame for the usbnet framework code to process.228 */229 static const u8 HEADER_END_OF_USB_PACKET[] =230 { 0x57, 0x5a, 0x00, 0x00, 0x08, 0x00 };231 static const u8 EXPECTED_UNKNOWN_HEADER_1[] =232 { 0x57, 0x43, 0x1e, 0x00, 0x15, 0x02 };233 static const u8 EXPECTED_UNKNOWN_HEADER_2[] =234 { 0x57, 0x50, 0x0e, 0x00, 0x00, 0x00 };235 int i = 0;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))) {254 netdev_dbg(dev->net,255 "Received expected unknown frame header: %6phC. Package length: %i\n",256 header_start,257 skb->len - KALMIA_HEADER_LENGTH);258 }259 else {260 netdev_err(dev->net,261 "Received unknown frame header: %6phC. Package length: %i\n",262 header_start,263 skb->len - KALMIA_HEADER_LENGTH);264 return 0;265 }266 }267 else268 netdev_dbg(dev->net,269 "Received header: %6phC. Package length: %i\n",270 header_start, skb->len - KALMIA_HEADER_LENGTH);271 272 /* subtract start header and end header */273 usb_packet_length = skb->len - (2 * KALMIA_HEADER_LENGTH);274 ether_packet_length = get_unaligned_le16(&header_start[2]);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_length280 + KALMIA_HEADER_LENGTH;281 is_last = true;282 }283 else {284 netdev_dbg(dev->net, "Correct package length #%i", i285 + 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;292 netdev_dbg(dev->net,293 "End header: %6phC. Package length: %i\n",294 header_start,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 325static 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_fixup331};332 333/*-------------------------------------------------------------------------*/334 335static const struct usb_device_id products[] = {336 /* The unswitched USB ID, to get the module auto loaded: */337 { USB_DEVICE(0x04e8, 0x689a) },338 /* The stick switched into modem (by e.g. usb_modeswitch): */339 { USB_DEVICE(0x04e8, 0x6889),340 .driver_info = (unsigned long) &kalmia_info, },341 { /* EMPTY == end of list */} };342MODULE_DEVICE_TABLE( usb, products);343 344static struct usb_driver kalmia_driver = {345 .name = "kalmia",346 .id_table = products,347 .probe = usbnet_probe,348 .disconnect = usbnet_disconnect,349 .suspend = usbnet_suspend,350 .resume = usbnet_resume,351 .disable_hub_initiated_lpm = 1,352};353 354module_usb_driver(kalmia_driver);355 356MODULE_AUTHOR("Marius Bjoernstad Kotsbak <marius@kotsbak.com>");357MODULE_DESCRIPTION("Samsung Kalmia USB network driver");358MODULE_LICENSE("GPL");359