1/* 2 * CDC Ethernet based the networking peripherals of Longcheer data card devices 3 * This driver is developed based on usbnet.c and cdc_ether.c 4 * Copyright (C) 2009 by kahn.qiao (Longcheer Technologies Co., Ltd.) 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will support Longcheer data card devices for Linux networking, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 19 */ 20 21#include <linux/module.h> 22#include <linux/init.h> 23#include <linux/netdevice.h> 24#include <linux/etherdevice.h> 25#include <linux/ethtool.h> 26#include <linux/workqueue.h> 27#include <linux/mii.h> 28#include <linux/usb.h> 29#include <linux/sched.h> 30#include <linux/ctype.h> 31#include <linux/usb/cdc.h> 32#include <linux/usbdevice_fs.h> 33 34#include <linux/version.h> 35#include "qmi_header.h" 36#include "qmi_oper.h" 37///////////////////////////////////////////////////////////////////////////////////////////////// 38#define DRIVER_VERSION "v2.07.00.00" 39#define DRIVER_AUTHOR "kahn qiao <kahn.qiao@Longcheer.com>" 40#define DRIVER_DESC "Longcheer ether driver for 3G data card ether device" 41////////////////////////////////////////////////////////////////////////////////////////////////////// 42#define RX_MAX_QUEUE_MEMORY (60 * 1518) 43#define RX_QLEN(dev) (((dev)->udev->speed == USB_SPEED_HIGH) ? \ 44 (RX_MAX_QUEUE_MEMORY/(dev)->rx_urb_size) : 4) 45#define TX_QLEN(dev) (((dev)->udev->speed == USB_SPEED_HIGH) ? \ 46 (RX_MAX_QUEUE_MEMORY/(dev)->hard_mtu) : 4) 47 48// reawaken network queue this soon after stopping; else watchdog barks 49#define TX_TIMEOUT_JIFFIES (5*HZ) 50 51// throttle rx/tx briefly after some faults, so khubd might disconnect() 52// us (it polls at HZ/4 usually) before we report too many false errors. 53#define THROTTLE_JIFFIES (HZ/8) 54 55// between wakeups 56#define UNLINK_TIMEOUT_MS 3 57#define PROCESS_ARP_PACKAGE 58#define NDIS_INIT_STATUS 59////////////////////////////////////////////////////////////////////////////////////////////// 60// randomly generated ethernet address 61static u8 node_id [ETH_ALEN]; 62 63static const char driver_name [] = "lc_ether"; 64 65/* use ethtool to change the level for any given device */ 66static int msg_level = -1; 67module_param (msg_level, int, 0); 68MODULE_PARM_DESC (msg_level, "Override default message level"); 69 70#pragma pack(push, 1) 71 72// ethernet headers 73#define ETH_TYPE_ARP 0x0806 74#define ETH_TYPE_IPV4 0x0800 75#define ETH_TYPE_IPV6 0x86DD 76 77#define ETH_LENGTH_OF_ADDRESS 6 78 79#define LC_INTERFACE_INDEX 0X04 80 81static QC_ETH_HDR fEthernetHeader; 82 83/*max ethernet pkt size 1514*/ 84#define lc_USB_RECEIVE_BUFFER_SIZE 1600L 85/*for Tin-layer-protocol (TLP)*/ 86#define lc_USB_MRECEIVE_BUFFER_SIZE 4096L 87/*for TLP*/ 88#define lc_USB_MRECEIVE_MAX_BUFFER_SIZE (1024*16) 89 90/////////////////////////////////////////////////////////////////////////////////////////// 91#define EVENT_TX_HALT 0 92#define EVENT_RX_HALT 1 93#define EVENT_RX_MEMORY 2 94#define EVENT_STS_SPLIT 3 95#define EVENT_LINK_RESET 4 96 97static int rt_debug = 0; 98module_param(rt_debug, bool, S_IRUGO|S_IWUSR); 99 100#if 0 101#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26) 102#include <linux/unaligned/access_ok.h> 103#else 104static inline u16 get_unaligned_le16(const void *p) 105{ 106 return le16_to_cpup((__le16 *)p); 107} 108 109static inline u32 get_unaligned_le32(const void *p) 110{ 111 return le32_to_cpup((__le32 *)p); 112} 113 114static inline void put_unaligned_le16(u16 val, void *p) 115{ 116 *((__le16 *)p) = cpu_to_le16(val); 117} 118 119static inline void put_unaligned_le32(u32 val, void *p) 120{ 121 *((__le32 *)p) = cpu_to_le32(val); 122} 123#endif 124#endif 125/* Add for DTS2011050903736 lxz 20110520 start*/ 126#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37) 127#define LINUX_VERSION37_LATER 1 128#else 129#define LINUX_VERSION37_LATER 0 130#endif 131 132static UInt8 fCurMacAddress[6]= 133 {0x00,0xA0,0xC6,0x00,0x00,0x00}; 134static UInt8 fDstMacAddress[6]= 135 {0x00,0xA0,0xC6,0x00,0x00,0x01}; 136 137#ifdef INIT_NDP16_OPTS 138#undef INIT_NDP16_OPTS 139#endif 140#ifdef INIT_NDP32_OPTS 141#undef INIT_NDP32_OPTS 142#endif 143 144static NDIS_QMI_STATUS ndis_status; 145 146#ifndef max 147#define max(_a, _b) (((_a) > (_b)) ? (_a) : (_b)) 148#endif 149 150#ifndef min 151#define min(_a, _b) (((_a) < (_b)) ? (_a) : (_b)) 152#endif 153 154struct lc_cdc_net{ 155 /* housekeeping */ 156 struct usb_device *udev; 157 struct usb_interface *intf; 158 const char *driver_name; 159 const char *driver_desc; 160 void *driver_priv; 161 wait_queue_head_t *wait; 162 struct mutex phy_mutex; 163 164 /* i/o info: pipes etc */ 165 unsigned in, out; 166 struct usb_host_endpoint *status; 167 unsigned maxpacket; 168 struct timer_list delay; 169 170 /* protocol/interface state */ 171 struct net_device *net; 172 struct net_device_stats stats; 173 int msg_enable; 174 unsigned long data [5]; 175 u32 xid; 176 u32 hard_mtu; /* count any extra framing */ 177 size_t rx_urb_size; /* size for rx urbs */ 178 struct mii_if_info mii; 179 180 /* various kinds of pending driver work */ 181 struct sk_buff_head rxq; 182 struct sk_buff_head txq; 183 struct sk_buff_head done; 184 struct urb *interrupt; 185 struct tasklet_struct bh; 186 187 struct work_struct kevent; 188 struct delayed_work status_work; 189 int qmi_sync; 190 unsigned long flags; 191 unsigned char suspend_count; 192}__attribute__((packed)) ; 193 194static inline struct usb_driver *driver_of(struct usb_interface *intf) 195{ 196 return to_usb_driver(intf->dev.driver); 197} 198 199 200/* Drivers that reuse some of the standard USB CDC infrastructure 201 * (notably, using multiple interfaces according to the CDC 202 * union descriptor) get some helper code. 203 */ 204struct lc_dev_state { 205 struct usb_cdc_header_desc *header; 206 struct usb_cdc_union_desc *u; 207 struct usb_cdc_ether_desc *ether; 208 struct usb_interface *control; 209 struct usb_interface *data; 210}; 211 212 213/* we record the state for each of our queued skbs */ 214enum skb_state { 215 illegal = 0, 216 tx_start, tx_done, 217 rx_start, rx_done, rx_cleanup 218}; 219 220struct skb_data { /* skb->cb is one of these */ 221 struct urb *urb; 222 struct lc_cdc_net *dev; 223 enum skb_state state; 224 size_t length; 225}; 226//////////////////////////////////////////////////////////////////////////////////////////////////////////////// 227#define devdbg(lc_cdc_net, fmt, arg...) \ 228 ((void)(rt_debug && printk(KERN_ERR "lc_cdc_driver######: " fmt "\n" , ## arg))) 229 230 231#define deverr(lc_cdc_net, fmt, arg...) \ 232 printk(KERN_ERR "%s: " fmt "\n" , (lc_cdc_net)->net->name , ## arg) 233#define devwarn(lc_cdc_net, fmt, arg...) \ 234 printk(KERN_WARNING "%s: " fmt "\n" , (lc_cdc_net)->net->name , ## arg) 235 236#define devinfo(lc_cdc_net, fmt, arg...) \ 237 printk(KERN_INFO "%s: " fmt "\n" , (lc_cdc_net)->net->name , ## arg); \ 238 239 240//////////////////////////////////////////////////////////////////////////////// 241#ifdef NDIS_INIT_STATUS 242static void lc_cdc_status(struct lc_cdc_net *dev, struct urb *urb); 243#endif 244static inline int lc_get_ethernet_addr(struct lc_cdc_net *dev); 245static int lc_cdc_bind(struct lc_cdc_net *dev, struct usb_interface *intf); 246void lc_cdc_unbind(struct lc_cdc_net *dev, struct usb_interface *intf); 247 248static void lc_cdc_check_status_work(); 249/*{ 250 struct delayed_work *option_suspend_wq 251}*/ 252 253static struct lc_cdc_net *g_cdc_dev = NULL; 254static int ndis_get_client_ID(struct lc_cdc_net *dev); 255static int ndis_get_version_info(struct lc_cdc_net *dev); 256static int ndis_set_instance_ID(struct lc_cdc_net *dev); 257static int ndis_set_data_format(struct lc_cdc_net *dev); 258static int ndis_release_client_ID(struct lc_cdc_net *dev); 259static int ndis_connect(struct lc_cdc_net *dev,char *accessString, 260 char *userName, 261 char *passWord, 262 UInt8 compression, 263 UInt32 ConnectIpMode); 264 265static int ndis_get_ip_addr(struct lc_cdc_net *dev); 266static int ndis_disconnect(struct lc_cdc_net *dev); 267static int lc_get_qmi_status(struct usb_interface *intf); 268 269#ifdef PROCESS_ARP_PACKAGE 270static void lc_skb_return_arp (struct lc_cdc_net *dev, struct sk_buff *skb); 271static void ProcessArpPacket(UInt8 *pData, UInt32 packetlength); 272static void ResponseArpPacket(UInt8 *pData, UInt32 packetlength); 273static bool FilterArpPacket(UInt8 *pData, UInt32 packetlength); 274#endif 275enum{ 276 NDIS_CMD_CONNECT_CMD = 0xA0, 277 NDIS_CMD_DISCONN_CMD, 278 NDIS_CMD_GET_VERSION, 279 NDIS_CMD_GET_STATUS, 280 NDIS_CMD_INIT_STATUS 281}; 282static spinlock_t qmi_request_lock; 283typedef struct __ndis_command_t{ 284int cmd; 285UInt8 data[WWAN_STRING_LEN*3+sizeof(UInt32)*2]; 286} ndis_command_t; 287 288typedef struct 289{ 290 int connection_status; 291 UInt32 ip_address; 292} WWAN_STATUS; 293 294/* handles CDC Ethernet and many other network "bulk data" interfaces */ 295int lc_get_endpoints(struct lc_cdc_net *dev, struct usb_interface *intf) 296{ 297 int tmp; 298 struct usb_host_interface *alt = NULL; 299 struct usb_host_endpoint *in = NULL, *out = NULL; 300 struct usb_host_endpoint *status = NULL; 301 302 for (tmp = 0; tmp < intf->num_altsetting; tmp++) { 303 unsigned ep; 304 305 in = out = status = NULL; 306 alt = intf->altsetting + tmp; 307 308 /* take the first altsetting with in-bulk + out-bulk; 309 * remember any status endpoint, just in case; 310 * ignore other endpoints and altsetttings. 311 */ 312 for (ep = 0; ep < alt->desc.bNumEndpoints; ep++) { 313 314 struct usb_host_endpoint *e; 315 int intr = 0; 316 317 e = alt->endpoint + ep; 318 switch (e->desc.bmAttributes) { 319 case USB_ENDPOINT_XFER_INT: 320 if (!usb_endpoint_dir_in(&e->desc)) 321 continue; 322 intr = 1; 323 /* FALLTHROUGH */ 324 case USB_ENDPOINT_XFER_BULK: 325 break; 326 default: 327 continue; 328 } 329 if (usb_endpoint_dir_in(&e->desc)) { 330 if (!intr && !in) 331 in = e; 332 else if (intr && !status) 333 status = e; 334 } else { 335 if (!out) 336 out = e; 337 } 338 } 339 if (in && out) 340 break; 341 } 342 if (!alt || !in || !out) 343 return -EINVAL; 344 if (alt->desc.bAlternateSetting != 0) { 345 tmp = usb_set_interface (dev->udev, alt->desc.bInterfaceNumber, 346 alt->desc.bAlternateSetting); 347 if (tmp < 0) 348 return tmp; 349 } 350 351 dev->in = usb_rcvbulkpipe (dev->udev, 352 in->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK); 353 dev->out = usb_sndbulkpipe (dev->udev, 354 out->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK); 355 dev->status = status; 356 return 0; 357} 358EXPORT_SYMBOL_GPL(lc_get_endpoints); 359#ifdef NDIS_INIT_STATUS 360static void intr_complete (struct urb *urb); 361 362static int init_status (struct lc_cdc_net *dev, struct usb_interface *intf) 363{ 364 char *buf = NULL; 365 unsigned pipe = 0; 366 unsigned maxp; 367 unsigned period; 368 369 370 pipe = usb_rcvintpipe (dev->udev, 371 dev->status->desc.bEndpointAddress 372 & USB_ENDPOINT_NUMBER_MASK); 373 maxp = usb_maxpacket (dev->udev, pipe, 0); 374 375 /* avoid 1 msec chatter: min 8 msec poll rate */ 376 period = max ((int) dev->status->desc.bInterval, 377 (dev->udev->speed == USB_SPEED_HIGH) ? 7 : 3); 378 379 buf = kmalloc (maxp, GFP_KERNEL); 380 if (buf) { 381 dev->interrupt = usb_alloc_urb (0, GFP_KERNEL); 382 if (!dev->interrupt) { 383 kfree (buf); 384 return -ENOMEM; 385 } else { 386 usb_fill_int_urb(dev->interrupt, dev->udev, pipe, 387 buf, maxp, intr_complete, dev, period); 388 devdbg(g_cdc_dev,"status ep%din, %d bytes period %d\n", 389 usb_pipeendpoint(pipe), maxp, period); 390 } 391 } 392 return 0; 393} 394#endif 395 396#ifdef PROCESS_ARP_PACKAGE 397 398static void ProcessArpPacket(UInt8 *pData, UInt32 packetlength) 399{ 400 // QC_ETH_HDR* pHdr = (QC_ETH_HDR*)pData; 401 QC_ARP_HDR* pARPHdr = (QC_ARP_HDR*)(pData + sizeof(QC_ETH_HDR)); 402 UInt8 tempHA[ETH_LENGTH_OF_ADDRESS] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; 403 UInt32 sz = 0; 404 405 // ignore non-ethernet HW type and non-request operation 406 if (ntohs(pARPHdr->HardwareType) != 1 407 || ntohs(pARPHdr->Operation) != 1) 408 { 409 devdbg(g_cdc_dev,"%s : drop arp without hw type and request,HardwareType=%u,Operation=%u.\n", 410 __func__, pARPHdr->HardwareType, pARPHdr->Operation); 411 return; 412 } 413 414 // ignore non ipv4 protocol type 415 if (ntohs(pARPHdr->ProtocolType) != ETH_TYPE_IPV4) 416 { 417 devdbg(g_cdc_dev,"%s : ignore packet not using ip v4,ProtocolType=%u.\n", 418 __func__, pARPHdr->ProtocolType); 419 return; 420 } 421 422 // validate HLEN and PLEN 423 if (pARPHdr->HLEN != ETH_LENGTH_OF_ADDRESS) 424 { 425 devdbg(g_cdc_dev,"ProcessArpPacket : invalid HLEN=%u,\n", pARPHdr->HLEN); 426 return; 427 } 428 429 if (pARPHdr->PLEN != 4) 430 { 431 devdbg(g_cdc_dev,"ProcessArpPacket : invalid PLEN=%u.\n", pARPHdr->PLEN); 432 return; 433 } 434 435 // Ignore gratuitous arp 436 if (pARPHdr->SenderIP == pARPHdr->TargetIP) 437 { 438 devdbg(g_cdc_dev,"ProcessArpPacket : ignore gratuitous arp.\n"); 439 return; 440 } 441 442 sz = memcmp(pARPHdr->TargetHA, tempHA, ETH_LENGTH_OF_ADDRESS); 443 444 if (pARPHdr->SenderIP != 0 && pARPHdr->TargetIP != ndis_status.fIPAddress) 445 { 446 devdbg(g_cdc_dev, "ProcessArpPacket : process sender ip is not null,SenderIP=%u,fIPAddress=%u,TargetIP=%u.\n", 447 pARPHdr->SenderIP, ndis_status.fIPAddress, pARPHdr->TargetIP); 448 ResponseArpPacket(pData, packetlength); 449 } 450 else if (pARPHdr->SenderIP == 0 && ETH_LENGTH_OF_ADDRESS == sz) 451 { 452 devdbg(g_cdc_dev,"ProcessArpPacket : process sender ip is null,senderIP=%u,TargetIP=%u.\n", pARPHdr->SenderIP, pARPHdr->TargetIP); 453 ResponseArpPacket(pData, packetlength); 454 } 455 else 456 { 457 devdbg(g_cdc_dev,"ProcessArpPacket : drop other arp.\n"); 458 } 459} 460 461static void ResponseArpPacket(UInt8 *pData, UInt32 packetlength) 462{ 463 QC_ETH_HDR* pHdr = (QC_ETH_HDR*)pData; 464 QC_ARP_HDR* pARPHdr = (QC_ARP_HDR*)(pData + sizeof(QC_ETH_HDR)); 465 466 QC_ETH_HDR* pSkbHdr = NULL; 467 QC_ARP_HDR* pSkbARPHdr = NULL; 468 469 struct sk_buff *skb; 470 struct skb_data *entry; 471 472 473 if ((skb = alloc_skb (packetlength + NET_IP_ALIGN, GFP_ATOMIC)) == NULL) { 474 deverr (g_cdc_dev, "no rx skb"); 475 // lc_defer_kevent (g_cdc_dev, EVENT_RX_MEMORY); 476 return; 477 } 478 skb->len = packetlength; 479 entry = (struct skb_data *) skb->cb; 480 entry->dev = g_cdc_dev; 481 entry->state = rx_start; 482 entry->length = 0; 483 484 pSkbHdr = (QC_ETH_HDR*)(skb->data); 485 pSkbARPHdr = (QC_ARP_HDR*)((UInt8*)pSkbHdr + sizeof(QC_ETH_HDR)); 486 487 memcpy(pSkbHdr,pData,packetlength); 488 489 // process ethernet header 490 memcpy(pSkbHdr->DstMacAddress, pHdr->SrcMacAddress, ETH_LENGTH_OF_ADDRESS); 491 // mac address from firmware 492 memcpy(pSkbHdr->SrcMacAddress, fDstMacAddress, ETH_LENGTH_OF_ADDRESS); 493 494 // process arp header 495 memcpy(pSkbARPHdr->TargetHA, pARPHdr->SenderHA, ETH_LENGTH_OF_ADDRESS); 496 pSkbARPHdr->SenderIP = pARPHdr->TargetIP; 497 498 memcpy(pSkbARPHdr->SenderHA, fDstMacAddress, ETH_LENGTH_OF_ADDRESS); 499 pSkbARPHdr->TargetIP = ndis_status.fIPAddress; 500 501 // operation reply 502 pSkbARPHdr->Operation =ntohs(0x0002); 503 504 // send back this packet 505 devdbg(g_cdc_dev,"ResponseArpPacket : send back the packet.\n"); 506 lc_skb_return_arp(g_cdc_dev, skb); 507 508 return; 509} 510 511static bool FilterArpPacket(UInt8 *pData, UInt32 packetlength) 512{ 513 QC_ETH_HDR* pHdr = (QC_ETH_HDR*)pData; 514 515 if(ETH_TYPE_ARP==ntohs(pHdr->EtherType)) 516 { 517 devdbg (g_cdc_dev, "ETH_TYPE_ARP."); 518 if (ndis_status.fIPAddress != 0) 519 { 520 ProcessArpPacket(pData, packetlength); 521 } 522 return true; 523 } 524 525 devdbg (g_cdc_dev, "not a arp package."); 526 527 return false; 528} 529#endif 530/* Passes this packet up the stack, updating its accounting. 531 * Some link protocols batch packets, so their rx_fixup paths 532 * can return clones as well as just modify the original skb. 533 */ 534void lc_skb_return (struct lc_cdc_net *dev, struct sk_buff *skb) 535{ 536 int status; 537 u32 sn; 538 539 devdbg(dev,"%s:......start.",__func__); 540 if(skb->len > 128) 541 { 542 sn = be32_to_cpu(*(u32 *)(skb->data + 0x26)); 543 devdbg(dev,"lc_skb_return,len:%d receive sn:%x, time:%ld-%ld",skb->len,sn,current_kernel_time().tv_sec,current_kernel_time().tv_nsec); 544 } 545 else 546 { 547 sn = be32_to_cpu(*(u32 *)(skb->data + 0x2a)); 548 devdbg(dev,"lc_skb_return,len:%d receive ack sn:%x, time:%ld-%ld",skb->len,sn,current_kernel_time().tv_sec,current_kernel_time().tv_nsec); 549 } 550#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,26) 551 skb->dev = dev->net; 552#endif 553 skb->data = skb->data -14; 554 memcpy(skb->data,&fEthernetHeader,sizeof(fEthernetHeader)); 555 skb->len = skb->len +14; 556// printk_hex(skb->data,skb->len); 557 skb->protocol = eth_type_trans (skb, dev->net); 558 dev->stats.rx_packets++; 559 dev->stats.rx_bytes += skb->len; 560 561 if (netif_msg_rx_status (dev)) 562 devdbg(g_cdc_dev,"< rx, len %zu, type 0x%x.\n", 563 skb->len + sizeof (struct ethhdr), skb->protocol); 564 memset (skb->cb, 0, sizeof (struct skb_data)); 565 status = netif_rx (skb); 566 if (status != NET_RX_SUCCESS && netif_msg_rx_err (dev)) 567 devdbg(g_cdc_dev,"netif_rx status %d.\n", status); 568} 569#ifdef PROCESS_ARP_PACKAGE 570static void lc_skb_return_arp (struct lc_cdc_net *dev, struct sk_buff *skb) 571{ 572 int status; 573 u32 sn; 574 575 devdbg(dev,"%s:......start.",__func__); 576#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,26) 577 skb->dev = dev->net; 578#endif 579 if(skb->len > 128) 580 { 581 sn = be32_to_cpu(*(u32 *)(skb->data + 0x26)); 582 devdbg(dev,"lc_skb_return,len:%d receive sn:%x, time:%ld-%ld",skb->len,sn,current_kernel_time().tv_sec,current_kernel_time().tv_nsec); 583 } 584 else 585 { 586 sn = be32_to_cpu(*(u32 *)(skb->data + 0x2a)); 587 devdbg(dev,"lc_skb_return,len:%d receive ack sn:%x, time:%ld-%ld",skb->len,sn,current_kernel_time().tv_sec,current_kernel_time().tv_nsec); 588 } 589 skb->protocol = eth_type_trans (skb, dev->net); 590 dev->stats.rx_packets++; 591 dev->stats.rx_bytes += skb->len; 592 593 if (netif_msg_rx_status (dev)) 594 devdbg(g_cdc_dev,"< rx, len %zu, type 0x%x.\n", 595 skb->len + sizeof (struct ethhdr), skb->protocol); 596 memset (skb->cb, 0, sizeof (struct skb_data)); 597 status = netif_rx (skb); 598 if (status != NET_RX_SUCCESS && netif_msg_rx_err (dev)) 599 devdbg(g_cdc_dev,"netif_rx status %d.\n", status); 600} 601#endif 602EXPORT_SYMBOL_GPL(lc_skb_return); 603 604// unlink pending rx/tx; completion handlers do all other cleanup 605 606static int unlink_urbs (struct lc_cdc_net *dev, struct sk_buff_head *q) 607{ 608 unsigned long flags; 609 struct sk_buff *skb, *skbnext; 610 int count = 0; 611 612 spin_lock_irqsave (&q->lock, flags); 613 for (skb = q->next; skb != (struct sk_buff *) q; skb = skbnext) { 614 struct skb_data *entry; 615 struct urb *urb; 616 int retval; 617 618 entry = (struct skb_data *) skb->cb; 619 urb = entry->urb; 620 skbnext = skb->next; 621 622 // during some PM-driven resume scenarios, 623 // these (async) unlinks complete immediately 624 retval = usb_unlink_urb (urb); 625 if (retval != -EINPROGRESS && retval != 0) 626 devdbg (dev, "unlink urb err, %d", retval); 627 else 628 count++; 629 } 630 spin_unlock_irqrestore (&q->lock, flags); 631 return count; 632} 633 634 635// Flush all pending rx urbs 636// minidrivers may need to do this when the MTU changes 637 638void lc_unlink_rx_urbs(struct lc_cdc_net *dev) 639{ 640 if (netif_running(dev->net)) { 641 (void) unlink_urbs (dev, &dev->rxq); 642 tasklet_schedule(&dev->bh); 643 } 644} 645EXPORT_SYMBOL_GPL(lc_unlink_rx_urbs); 646 647/*------------------------------------------------------------------------- 648 * 649 * Network Device Driver (peer link to "Host Device", from USB host) 650 * 651 *-------------------------------------------------------------------------*/ 652 653static int lc_change_mtu (struct net_device *net, int new_mtu) 654{ 655 struct lc_cdc_net *dev = netdev_priv(net); 656 int ll_mtu = new_mtu + net->hard_header_len; 657 int old_hard_mtu = dev->hard_mtu; 658 int old_rx_urb_size = dev->rx_urb_size; 659 660// printk("%s............................%d.\n",__func__,__LINE__); 661 if (new_mtu <= 0) 662 return -EINVAL; 663 // no second zero-length packet read wanted after mtu-sized packets 664 if ((ll_mtu % dev->maxpacket) == 0) 665 return -EDOM; 666 net->mtu = new_mtu; 667 668 dev->hard_mtu = net->mtu + net->hard_header_len; 669 if (dev->rx_urb_size == old_hard_mtu) { 670 dev->rx_urb_size = dev->hard_mtu; 671 if (dev->rx_urb_size > old_rx_urb_size) 672 lc_unlink_rx_urbs(dev); 673 } 674 675 devdbg(g_cdc_dev,"change mtu :%d, urb_size:%d",new_mtu,dev->rx_urb_size); 676 677 return 0; 678} 679 680/*-------------------------------------------------------------------------*/ 681//#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 30) 682static struct net_device_stats *lc_get_stats (struct net_device *net) 683{ 684 struct lc_cdc_net *dev = netdev_priv(net); 685 return &dev->stats; 686} 687//#endif 688/*-------------------------------------------------------------------------*/ 689 690static void tx_defer_bh(struct lc_cdc_net *dev, struct sk_buff *skb, struct sk_buff_head *list) 691{ 692 unsigned long flags; 693 694 spin_lock_irqsave(&list->lock, flags); 695 __skb_unlink(skb, list); 696 spin_unlock(&list->lock); 697 spin_lock(&dev->done.lock); 698 __skb_queue_tail(&dev->done, skb); 699 if (1 <= dev->done.qlen) 700 tasklet_schedule(&dev->bh); 701 spin_unlock_irqrestore(&dev->done.lock, flags); 702} 703static void rx_defer_bh(struct lc_cdc_net *dev, struct sk_buff *skb, struct sk_buff_head *list) 704{ 705 unsigned long flags; 706 spin_lock_irqsave(&list->lock, flags); 707 __skb_unlink(skb, list); 708 spin_unlock_irqrestore(&list->lock, flags); 709 710 { 711 spin_lock_irqsave(&dev->done.lock, flags); 712 __skb_queue_tail(&dev->done, skb); 713 if (1 <= dev->done.qlen){ 714 tasklet_schedule(&dev->bh); 715 } 716 spin_unlock_irqrestore(&dev->done.lock, flags); 717 } 718} 719//////////////////////// 720 721/* some work can't be done in tasklets, so we use keventd 722 * 723 * NOTE: annoying asymmetry: if it's active, schedule_work() fails, 724 * but tasklet_schedule() doesn't. hope the failure is rare. 725 */ 726void lc_defer_kevent (struct lc_cdc_net *dev, int work) 727{ 728 set_bit (work, &dev->flags); 729 if (!schedule_work (&dev->kevent)) 730 deverr (dev, "kevent %d may have been dropped", work); 731 else 732 devdbg (dev, "kevent %d scheduled", work); 733} 734EXPORT_SYMBOL_GPL(lc_defer_kevent); 735 736/*-------------------------------------------------------------------------*/ 737 738 739 740 741static void rx_complete (struct urb *urb); 742static void rx_submit (struct lc_cdc_net *dev, struct urb *urb, gfp_t flags) 743{ 744 struct sk_buff *skb; 745 struct skb_data *entry; 746 int retval = 0; 747 unsigned long lockflags; 748 size_t size = dev->rx_urb_size; 749// UInt8 750 751 devdbg(dev,"%s.....started.",__func__); 752 if ((skb = alloc_skb (size +14+ NET_IP_ALIGN, flags)) == NULL) { 753 deverr (dev, "no rx skb"); 754 lc_defer_kevent (dev, EVENT_RX_MEMORY); 755 usb_free_urb (urb); 756 return; 757 } 758// memcpy(skb->data+2,&fEthernetHeader,sizeof(fEthernetHeader)); 759 skb_reserve (skb, 14+NET_IP_ALIGN); 760 761 entry = (struct skb_data *) skb->cb; 762 entry->urb = urb; 763 entry->dev = dev; 764 entry->state = rx_start; 765 entry->length = 0; 766 767 devdbg(dev,"%s:get data size=%d.",__func__,size); 768// printk_hex((void*)skb->data,size);//memcpy(fEthernetHeader.DstMacAddress, fCurMacAddress, ETH_LENGTH_OF_ADDRESS); 769 770 usb_fill_bulk_urb (urb, dev->udev, dev->in, 771 skb->data, size, rx_complete, skb); 772 773 774 spin_lock_irqsave (&dev->rxq.lock, lockflags); 775 776 777 if (netif_running (dev->net) 778 && netif_device_present (dev->net) 779 && !test_bit (EVENT_RX_HALT, &dev->flags)) { 780 switch (retval = usb_submit_urb (urb, GFP_ATOMIC)) { 781 782 case 0://submit successfully 783 __skb_queue_tail (&dev->rxq, skb); 784 break; 785 case -EPIPE: 786 lc_defer_kevent (dev, EVENT_RX_HALT); 787 break; 788 case -ENOMEM: 789 lc_defer_kevent (dev, EVENT_RX_MEMORY); 790 break; 791 case -ENODEV: 792 if (netif_msg_ifdown (dev)) 793 printk ("%s:device gone.",__func__); 794 netif_device_detach (dev->net); 795 break; 796 default: 797 if (netif_msg_rx_err (dev)) 798 printk ("%s:rx submit, %d",__func__, retval); 799 tasklet_schedule (&dev->bh); 800 break; 801 } 802 } else { 803 if (netif_msg_ifdown (dev)) 804 printk ("%s:rx: stopped",__func__); 805 retval = -ENOLINK; 806 } 807 spin_unlock_irqrestore (&dev->rxq.lock, lockflags); 808 809 devdbg(dev,"usb_submit_urb status:%x, time:%ld-%ld.",retval,current_kernel_time().tv_sec,current_kernel_time().tv_nsec); 810 811 if (retval) { 812 813 dev_kfree_skb_any (skb); 814 usb_free_urb (urb); 815 } 816} 817 818/*-------------------------------------------------------------------------*/ 819 820static inline void rx_process (struct lc_cdc_net *dev, struct sk_buff *skb) 821{ 822 //devdbg(dev,"get into %s .",__func__); 823 824 //skb->len = skb->len; 825 devdbg(dev,"%s: stk->len=%d.",__func__,skb->len); 826 /* if(skb->len<500&&skb->len>10) 827 { 828 printk_hex(skb->data,skb->len); 829 }*/ 830 if (skb->len){ 831 lc_skb_return (dev, skb); 832 } 833 else { 834 if (netif_msg_rx_err (dev)) 835 devdbg (dev, "drop"); 836 dev->stats.rx_errors++; 837 skb_queue_tail (&dev->done, skb); 838 } 839} 840 841/*-------------------------------------------------------------------------*/ 842static void rx_complete (struct urb *urb) 843{ 844 struct sk_buff *skb = (struct sk_buff *) urb->context; 845 struct skb_data *entry = (struct skb_data *) skb->cb; 846 struct lc_cdc_net *dev = entry->dev; 847 int urb_status = urb->status; 848 849 devdbg(g_cdc_dev,"rx_complete,urb:%p,rx length %d, time %ld-%ld.\n",urb, urb->actual_length,current_kernel_time().tv_sec,current_kernel_time().tv_nsec); 850 skb_put (skb, urb->actual_length); 851 entry->state = rx_done; 852 entry->urb = NULL; 853 854 switch (urb_status) { 855 /* success */ 856 case 0: 857 if (skb->len < dev->net->hard_header_len) { 858 entry->state = rx_cleanup; 859 dev->stats.rx_errors++; 860 dev->stats.rx_length_errors++; 861 if (netif_msg_rx_err (dev)) 862 devdbg (dev, "rx length %d", skb->len); 863 } 864 break; 865 866 /* stalls need manual reset. this is rare ... except that 867 * when going through USB 2.0 TTs, unplug appears this way. 868 * we avoid the highspeed version of the ETIMEOUT/EILSEQ 869 * storm, recovering as needed. 870 */ 871 case -EPIPE: 872 dev->stats.rx_errors++; 873 lc_defer_kevent (dev, EVENT_RX_HALT); 874 // FALLTHROUGH 875 876 /* software-driven interface shutdown */ 877 case -ECONNRESET: /* async unlink */ 878 case -ESHUTDOWN: /* hardware gone */ 879 if (netif_msg_ifdown (dev)) 880 devdbg (dev, "rx shutdown, code %d", urb_status); 881 goto block; 882 883 /* we get controller i/o faults during khubd disconnect() delays. 884 * throttle down resubmits, to avoid log floods; just temporarily, 885 * so we still recover when the fault isn't a khubd delay. 886 */ 887 case -EPROTO: 888 case -ETIME: 889 case -EILSEQ: 890 dev->stats.rx_errors++; 891 if (!timer_pending (&dev->delay)) { 892 mod_timer (&dev->delay, jiffies + THROTTLE_JIFFIES); 893 if (netif_msg_link (dev)) 894 devdbg (dev, "rx throttle %d", urb_status); 895 } 896block: 897 entry->state = rx_cleanup; 898 entry->urb = urb; 899 urb = NULL; 900 break; 901 902 /* data overrun ... flush fifo? */ 903 case -EOVERFLOW: 904 dev->stats.rx_over_errors++; 905 // FALLTHROUGH 906 907 default: 908 entry->state = rx_cleanup; 909 dev->stats.rx_errors++; 910 if (netif_msg_rx_err (dev)) 911 devdbg (dev, "rx status %d", urb_status); 912 break; 913 } 914 915 rx_defer_bh(dev, skb, &dev->rxq); 916 917 if (urb) { 918 if (netif_running (dev->net) 919 && !test_bit (EVENT_RX_HALT, &dev->flags)) { 920 rx_submit (dev, urb, GFP_ATOMIC); 921 return; 922 } 923 usb_free_urb (urb); 924 } 925 if (netif_msg_rx_err (dev)) 926 printk ("no read resubmitted.\n"); 927} 928#ifdef NDIS_INIT_STATUS 929static void intr_complete (struct urb *urb) 930{ 931 struct lc_cdc_net *dev = urb->context; 932 int status = urb->status; 933 934 devdbg(g_cdc_dev,"%s:...init status complete.\n",__func__); 935 switch (status) { 936 /* success */ 937 case 0: 938 lc_cdc_status(dev, urb); 939 break; 940 941 /* software-driven interface shutdown */ 942 case -ENOENT: /* urb killed */ 943 case -ESHUTDOWN: /* hardware gone */ 944 if (netif_msg_ifdown (dev)) 945 devdbg (dev, "intr shutdown, code %d", status); 946 return; 947 948 /* NOTE: not throttling like RX/TX, since this endpoint 949 * already polls infrequently 950 */ 951 default: 952 devdbg(g_cdc_dev,"intr status %d.\n", status); 953 break; 954 } 955 956 if (!netif_running (dev->net)) 957 return; 958 959 memset(urb->transfer_buffer, 0, urb->transfer_buffer_length); 960 status = usb_submit_urb (urb, GFP_ATOMIC); 961 if (status != 0 && netif_msg_timer (dev)) 962 devdbg(g_cdc_dev,"intr resubmit --> %d.\n", status); 963} 964#endif 965/*-------------------------------------------------------------------------*/ 966/*-------------------------------------------------------------------------*/ 967 968// precondition: never called in_interrupt 969 970static int lc_stop (struct net_device *net) 971{ 972 struct lc_cdc_net *dev = netdev_priv(net); 973 int temp; 974 DECLARE_WAIT_QUEUE_HEAD_ONSTACK (unlink_wakeup); 975 DECLARE_WAITQUEUE (wait, current); 976 977 netif_stop_queue (net); 978 979 if (netif_msg_ifdown (dev)) 980 devdbg(g_cdc_dev,"stop stats: rx/tx %ld/%ld, errs %ld/%ld", 981 dev->stats.rx_packets, dev->stats.tx_packets, 982 dev->stats.rx_errors, dev->stats.tx_errors 983 ); 984 985 // ensure there are no more active urbs 986 add_wait_queue (&unlink_wakeup, &wait); 987 dev->wait = &unlink_wakeup; 988 temp = unlink_urbs (dev, &dev->txq) + unlink_urbs (dev, &dev->rxq); 989 990 // maybe wait for deletions to finish. 991 while (!skb_queue_empty(&dev->rxq) 992 && !skb_queue_empty(&dev->txq) 993 && !skb_queue_empty(&dev->done)) { 994 msleep(UNLINK_TIMEOUT_MS); 995 if (netif_msg_ifdown (dev)) 996 devdbg(g_cdc_dev,"waited for %d urb completions", temp); 997 } 998 dev->wait = NULL; 999 remove_wait_queue (&unlink_wakeup, &wait); 1000 1001 usb_kill_urb(dev->interrupt); 1002 1003 /* deferred work (task, timer, softirq) must also stop. 1004 * can't flush_scheduled_work() until we drop rtnl (later), 1005 * else workers could deadlock; so make workers a NOP. 1006 */ 1007 dev->flags = 0; 1008 del_timer_sync (&dev->delay); 1009 tasklet_kill (&dev->bh); 1010 usb_autopm_put_interface(dev->intf); 1011 1012 return 0; 1013} 1014 1015/*-------------------------------------------------------------------------*/ 1016 1017// posts reads, and enables write queuing 1018 1019// precondition: never called in_interrupt 1020 1021static int lc_open (struct net_device *net) 1022{ 1023 struct lc_cdc_net *dev = netdev_priv(net); 1024 int retval; 1025 if ((retval = usb_autopm_get_interface(dev->intf)) < 0) { 1026 if (netif_msg_ifup (dev)) 1027 devdbg(g_cdc_dev,"resumption fail (%d) lc_cdc_net usb-%s-%s, %s", 1028 retval, 1029 dev->udev->bus->bus_name, dev->udev->devpath, 1030 dev->driver_desc); 1031 goto done_nopm; 1032 } 1033 1034 /* start any status interrupt transfer */ 1035 if (dev->interrupt) { 1036 retval = usb_submit_urb (dev->interrupt, GFP_KERNEL); 1037 if (retval < 0) { 1038 if (netif_msg_ifup (dev)) 1039 deverr (dev, "intr submit %d", retval); 1040 goto done; 1041 } 1042 } 1043 1044 netif_start_queue (net); 1045 1046 // delay posting reads until we're fully open 1047 tasklet_schedule (&dev->bh); 1048 return retval; 1049done: 1050 usb_autopm_put_interface(dev->intf); 1051done_nopm: 1052 return retval; 1053} 1054 1055/*-------------------------------------------------------------------------*/ 1056 1057/* ethtool methods; minidrivers may need to add some more, but 1058 * they'll probably want to use this base set. 1059 */ 1060 1061int lc_get_settings (struct net_device *net, struct ethtool_cmd *cmd) 1062{ 1063 struct lc_cdc_net *dev = netdev_priv(net); 1064 1065 if (!dev->mii.mdio_read) 1066 return -EOPNOTSUPP; 1067 1068 return mii_ethtool_gset(&dev->mii, cmd); 1069} 1070EXPORT_SYMBOL_GPL(lc_get_settings); 1071 1072int lc_set_settings (struct net_device *net, struct ethtool_cmd *cmd) 1073{ 1074 struct lc_cdc_net *dev = netdev_priv(net); 1075 int retval; 1076 1077 if (!dev->mii.mdio_write) 1078 return -EOPNOTSUPP; 1079 1080 retval = mii_ethtool_sset(&dev->mii, cmd); 1081 1082 return retval; 1083 1084} 1085EXPORT_SYMBOL_GPL(lc_set_settings); 1086 1087u32 lc_get_link (struct net_device *net) 1088{ 1089 struct lc_cdc_net *dev = netdev_priv(net); 1090 1091 /* if the device has mii operations, use those */ 1092 if (dev->mii.mdio_read) 1093 return mii_link_ok(&dev->mii); 1094 1095 /* Otherwise, say we're up (to avoid breaking scripts) */ 1096 return 1; 1097} 1098EXPORT_SYMBOL_GPL(lc_get_link); 1099 1100int lc_nway_reset(struct net_device *net) 1101{ 1102 struct lc_cdc_net *dev = netdev_priv(net); 1103 1104 if (!dev->mii.mdio_write) 1105 return -EOPNOTSUPP; 1106 1107 return mii_nway_restart(&dev->mii); 1108} 1109EXPORT_SYMBOL_GPL(lc_nway_reset); 1110 1111void lc_get_drvinfo (struct net_device *net, struct ethtool_drvinfo *info) 1112{ 1113 struct lc_cdc_net *dev = netdev_priv(net); 1114 1115 strncpy (info->driver, dev->driver_name, sizeof info->driver); 1116 strncpy (info->version, DRIVER_VERSION, sizeof info->version); 1117 strncpy (info->fw_version, dev->driver_desc, 1118 sizeof info->fw_version); 1119 usb_make_path (dev->udev, info->bus_info, sizeof info->bus_info); 1120} 1121EXPORT_SYMBOL_GPL(lc_get_drvinfo); 1122 1123u32 lc_get_msglevel (struct net_device *net) 1124{ 1125 struct lc_cdc_net *dev = netdev_priv(net); 1126 1127 return dev->msg_enable; 1128} 1129EXPORT_SYMBOL_GPL(lc_get_msglevel); 1130 1131void lc_set_msglevel (struct net_device *net, u32 level) 1132{ 1133 struct lc_cdc_net *dev = netdev_priv(net); 1134 1135 dev->msg_enable = level; 1136} 1137EXPORT_SYMBOL_GPL(lc_set_msglevel); 1138 1139/* drivers may override default ethtool_ops in their bind() routine */ 1140static struct ethtool_ops lc_ethtool_ops = { 1141 .get_settings = lc_get_settings, 1142 .set_settings = lc_set_settings, 1143 .get_link = lc_get_link, 1144 .nway_reset = lc_nway_reset, 1145 .get_drvinfo = lc_get_drvinfo, 1146 .get_msglevel = lc_get_msglevel, 1147 .set_msglevel = lc_set_msglevel, 1148}; 1149 1150/*-------------------------------------------------------------------------*/ 1151 1152/* work that cannot be done in interrupt context uses keventd. 1153 * 1154 * NOTE: with 2.5 we could do more of this using completion callbacks, 1155 * especially now that control transfers can be queued. 1156 */ 1157static void 1158kevent (struct work_struct *work) 1159{ 1160 struct lc_cdc_net *dev = 1161 container_of(work, struct lc_cdc_net, kevent); 1162 int status; 1163 1164 /* usb_clear_halt() needs a thread context */ 1165 devdbg(dev,"%s start.....",__func__); 1166 if (test_bit (EVENT_TX_HALT, &dev->flags)) { 1167 unlink_urbs (dev, &dev->txq); 1168 status = usb_clear_halt (dev->udev, dev->out); 1169 if (status < 0 1170 && status != -EPIPE 1171 && status != -ESHUTDOWN) { 1172 if (netif_msg_tx_err (dev)) 1173 deverr (dev, "can't clear tx halt, status %d", 1174 status); 1175 } else { 1176 clear_bit (EVENT_TX_HALT, &dev->flags); 1177 if (status != -ESHUTDOWN) 1178 netif_wake_queue (dev->net); 1179 } 1180 } 1181 if (test_bit (EVENT_RX_HALT, &dev->flags)) { 1182 unlink_urbs (dev, &dev->rxq); 1183 status = usb_clear_halt (dev->udev, dev->in); 1184 if (status < 0 1185 && status != -EPIPE 1186 && status != -ESHUTDOWN) { 1187 if (netif_msg_rx_err (dev)) 1188 deverr (dev, "can't clear rx halt, status %d", 1189 status); 1190 } else { 1191 clear_bit (EVENT_RX_HALT, &dev->flags); 1192 tasklet_schedule (&dev->bh); 1193 } 1194 } 1195 1196 /* tasklet could resubmit itself forever if memory is tight */ 1197 if (test_bit (EVENT_RX_MEMORY, &dev->flags)) { 1198 struct urb *urb = NULL; 1199 1200 if (netif_running (dev->net)) 1201 urb = usb_alloc_urb (0, GFP_KERNEL); 1202 else 1203 clear_bit (EVENT_RX_MEMORY, &dev->flags); 1204 if (urb != NULL) { 1205 clear_bit (EVENT_RX_MEMORY, &dev->flags); 1206 rx_submit (dev, urb, GFP_KERNEL); 1207 tasklet_schedule (&dev->bh); 1208 } 1209 } 1210 1211 if (test_bit (EVENT_LINK_RESET, &dev->flags)) { 1212 clear_bit (EVENT_LINK_RESET, &dev->flags); 1213 } 1214 1215 if (dev->flags) 1216 devdbg (dev, "kevent done, flags = 0x%lx", 1217 dev->flags); 1218} 1219 1220/*-------------------------------------------------------------------------*/ 1221 1222static void tx_complete (struct urb *urb) 1223{ 1224 struct sk_buff *skb = (struct sk_buff *) urb->context; 1225 struct skb_data *entry = (struct skb_data *) skb->cb; 1226 struct lc_cdc_net *dev = entry->dev; 1227 1228 devdbg(dev,"tx_complete,status:%d,len:%d, *********time:%ld-%ld.",urb->status,entry->length,current_kernel_time().tv_sec,current_kernel_time().tv_nsec); 1229 1230 if (urb->status == 0) { 1231 dev->stats.tx_packets++; 1232 dev->stats.tx_bytes += entry->length; 1233 } else { 1234 dev->stats.tx_errors++; 1235 devdbg(dev,"%s:%d.",__func__,__LINE__); 1236 switch (urb->status) { 1237 case -EPIPE: 1238 lc_defer_kevent (dev, EVENT_TX_HALT); 1239 devdbg(dev,"%s:%d.",__func__,__LINE__); 1240 break; 1241 1242 /* software-driven interface shutdown */ 1243 case -ECONNRESET: // async unlink 1244 case -ESHUTDOWN: // hardware gone 1245 devdbg(dev,"%s:%d.",__func__,__LINE__); 1246 break; 1247 1248 // like rx, tx gets controller i/o faults during khubd delays 1249 // and so it uses the same throttling mechanism. 1250 case -EPROTO: 1251 case -ETIME: 1252 case -EILSEQ: 1253 if (!timer_pending (&dev->delay)) { 1254 mod_timer (&dev->delay, 1255 jiffies + THROTTLE_JIFFIES); 1256 if (netif_msg_link (dev)) 1257 devdbg(dev, "tx throttle %d", 1258 urb->status); 1259 } 1260 netif_stop_queue (dev->net); 1261 devdbg(dev,"%s:%d.",__func__,__LINE__); 1262 break; 1263 default: 1264 if (netif_msg_tx_err (dev)) 1265 devdbg(dev,"tx err %d.", entry->urb->status); 1266 break; 1267 } 1268 } 1269 1270 urb->dev = NULL; 1271 entry->state = tx_done; 1272 tx_defer_bh(dev, skb, &dev->txq); 1273} 1274 1275/*-------------------------------------------------------------------------*/ 1276 1277static void lc_tx_timeout (struct net_device *net) 1278{ 1279 struct lc_cdc_net *dev = netdev_priv(net); 1280 1281 unlink_urbs (dev, &dev->txq); 1282 tasklet_schedule (&dev->bh); 1283 1284 // FIXME: device recovery -- reset? 1285} 1286 1287/*-------------------------------------------------------------------------*/ 1288 1289static int lc_start_xmit (struct sk_buff *skb, struct net_device *net) 1290{ 1291 struct lc_cdc_net *dev = netdev_priv(net); 1292 int length; 1293 int retval = NET_XMIT_SUCCESS; 1294 struct urb *urb = NULL; 1295 struct skb_data *entry; 1296 unsigned long flags; 1297 // bool process_arp = false; 1298 1299 length = skb->len; 1300#ifdef PROCESS_ARP_PACKAGE 1301 if(ndis_status.fIPAddress!=0&&FilterArpPacket(skb->data,skb->len)) 1302 { 1303 goto drop; 1304 } 1305#endif 1306 if (!(urb = usb_alloc_urb (0, GFP_ATOMIC))) { 1307 if (netif_msg_tx_err (dev)) 1308 devdbg (dev, "no urb"); 1309 goto drop; 1310 } 1311 1312 entry = (struct skb_data *) skb->cb; 1313 entry->urb = urb; 1314 entry->dev = dev; 1315 entry->state = tx_start; 1316 entry->length = length; 1317 1318 if(ndis_status.fIPAddress!=0) 1319 { 1320 usb_fill_bulk_urb (urb, dev->udev, dev->out, 1321 skb->data+14, skb->len-14, tx_complete, skb); 1322 }else 1323 { 1324 usb_fill_bulk_urb (urb, dev->udev, dev->out, 1325 skb->data, skb->len, tx_complete, skb); 1326 } 1327 1328 /* don't assume the hardware handles USB_ZERO_PACKET 1329 * NOTE: strictly conforming cdc-ether devices should expect 1330 * the ZLP here, but ignore the one-byte packet. 1331 */ 1332 if ((length % dev->maxpacket) == 0) { 1333 urb->transfer_buffer_length++; 1334 if (skb_tailroom(skb)) { 1335 skb->data[skb->len] = 0; 1336 __skb_put(skb, 1); 1337 } 1338 } 1339 1340 devdbg(dev,"lc_start_xmit ,usb_submit_urb,len:%d, time:%ld-%ld.",skb->len,current_kernel_time().tv_sec,current_kernel_time().tv_nsec); 1341 1342 spin_lock_irqsave (&dev->txq.lock, flags); 1343 1344 switch ((retval = usb_submit_urb (urb, GFP_ATOMIC))) { 1345 case -EPIPE: 1346 netif_stop_queue (net); 1347 lc_defer_kevent (dev, EVENT_TX_HALT); 1348 devdbg(dev,"%s:%d.",__func__,__LINE__); 1349 break; 1350 default: 1351 if (netif_msg_tx_err (dev)) 1352 { 1353 printk ("tx: submit urb err %d.\n", retval); 1354 } 1355 devdbg(dev,"%s:%d.",__func__,__LINE__); 1356 break; 1357 case 0: 1358 net->trans_start = jiffies; 1359 __skb_queue_tail (&dev->txq, skb); 1360 if (dev->txq.qlen >= TX_QLEN (dev)) 1361 { 1362 netif_stop_queue (net); 1363 devdbg(dev,"%s:%d.",__func__,__LINE__); 1364 } 1365 } 1366 spin_unlock_irqrestore (&dev->txq.lock, flags); 1367 1368 if (retval) { 1369 if (netif_msg_tx_err (dev)) 1370 devdbg(dev,"drop, code %d", retval); 1371drop: 1372 retval = NET_XMIT_SUCCESS; 1373 dev->stats.tx_dropped++; 1374 if (skb) 1375 dev_kfree_skb_any (skb); 1376 usb_free_urb (urb); 1377 } else if (netif_msg_tx_queued (dev)) { 1378 devdbg (dev, "> tx, len %d, type 0x%x", 1379 length, skb->protocol); 1380 } 1381 return retval; 1382} 1383 1384 1385/*-------------------------------------------------------------------------*/ 1386 1387// tasklet (work deferred from completions, in_irq) or timer 1388 1389static void lc_bh (unsigned long param) 1390{ 1391 struct lc_cdc_net *dev = (struct lc_cdc_net *) param; 1392 struct sk_buff *skb; 1393 struct skb_data *entry; 1394 1395 devdbg(dev,"get into ..........%s.",__func__); 1396 while ((skb = skb_dequeue (&dev->done))) { 1397 entry = (struct skb_data *) skb->cb; 1398 devdbg(dev,"%s:entry->state=%d.",__func__,entry->state); 1399 switch (entry->state) { 1400 case rx_done: 1401 entry->state = rx_cleanup; 1402 rx_process (dev, skb); 1403 continue; 1404 case tx_done: 1405 case rx_cleanup: 1406 usb_free_urb (entry->urb); 1407 dev_kfree_skb (skb); 1408 continue; 1409 default: 1410 printk ("%s:bogus skb state %d.\n", __func__,entry->state); 1411 } 1412 } 1413 1414 // waiting for all pending urbs to complete? 1415 if (dev->wait) { 1416 devdbg(dev,"%s.............%d.",__func__,__LINE__); 1417 if ((dev->txq.qlen + dev->rxq.qlen + dev->done.qlen) == 0) { 1418 wake_up (dev->wait); 1419 } 1420 1421 // or are we maybe short a few urbs? 1422 } else if (netif_running (dev->net) 1423 && netif_device_present (dev->net) 1424 && !timer_pending (&dev->delay) 1425 && !test_bit (EVENT_RX_HALT, &dev->flags)) { 1426 int temp = dev->rxq.qlen; 1427 int qlen = RX_QLEN (dev); 1428 devdbg(dev,"%s.............%d.",__func__,__LINE__); 1429 1430 if (temp < qlen) { 1431 struct urb *urb; 1432 int i; 1433 devdbg(dev,"%s.............%d.",__func__,__LINE__); 1434 // don't refill the queue all at once 1435 for (i = 0; i < 10 && dev->rxq.qlen < qlen; i++) { 1436 devdbg(dev,"%s.............%d.",__func__,__LINE__); 1437 urb = usb_alloc_urb (0, GFP_ATOMIC); 1438 if (urb != NULL) 1439 rx_submit (dev, urb, GFP_ATOMIC); 1440 } 1441 if (temp != dev->rxq.qlen && netif_msg_link (dev)) 1442 printk ("rxqlen %d --> %d.\n", 1443 temp, dev->rxq.qlen); 1444 if (dev->rxq.qlen < qlen) 1445 tasklet_schedule (&dev->bh); 1446 } 1447 if (dev->txq.qlen < TX_QLEN (dev)) 1448 netif_wake_queue (dev->net); 1449 } 1450} 1451 1452 1453/*------------------------------------------------------------------------- 1454 * 1455 * USB Device Driver support 1456 * 1457 *-------------------------------------------------------------------------*/ 1458 1459// precondition: never called in_interrupt 1460 1461void lc_disconnect (struct usb_interface *intf) 1462{ 1463 struct lc_cdc_net *dev; 1464 struct usb_device *xdev; 1465 struct net_device *net; 1466 1467 dev = usb_get_intfdata(intf); 1468 usb_set_intfdata(intf, NULL); 1469 if (!dev) 1470 return; 1471 1472 xdev = interface_to_usbdev (intf); 1473 1474 if (netif_msg_probe (dev)) 1475 devinfo (dev, "unregister '%s' usb-%s-%s, %s", 1476 intf->dev.driver->name, 1477 xdev->bus->bus_name, xdev->devpath, 1478 dev->driver_desc); 1479 1480 ndis_release_client_ID(g_cdc_dev); 1481#if 0 1482 cancel_delayed_work_sync(&dev->status_work); 1483#endif 1484 net = dev->net; 1485 1486 /* we don't hold rtnl here ... */ 1487 flush_scheduled_work (); 1488 1489 lc_cdc_unbind(dev, intf); 1490 unregister_netdev (net); 1491 free_netdev(net); 1492 usb_put_dev (xdev); 1493} 1494EXPORT_SYMBOL_GPL(lc_disconnect); 1495 1496static int lc_ndis_ioctl(struct net_device *dev,struct ifreq *req, int cmd) 1497{ 1498 ndis_command_t* pndis_req = NULL; 1499 int ret = -1; 1500 //printk("..............................\n"); 1501 devdbg(dev,"get into %s,cmd=%d.",__func__,cmd); 1502 1503 if(!netif_running(dev)||cmd!=SIOCDEVPRIVATE) 1504 return -EINVAL; 1505 1506 pndis_req = (ndis_command_t*)req->ifr_data; 1507 switch(pndis_req->cmd) 1508 { 1509 case NDIS_CMD_INIT_STATUS: 1510 { 1511 lc_get_qmi_status(g_cdc_dev->intf); 1512 if(g_cdc_dev->qmi_sync==0) 1513 { 1514 lc_cdc_check_status_work(); 1515 } 1516 } 1517 break; 1518 case NDIS_CMD_CONNECT_CMD: 1519 { 1520 WWAN_CONNECT_PARAMS* parms = NULL; 1521 1522 devdbg(dev,"%s:connect ioctl.",__func__); 1523 1524 parms = (WWAN_CONNECT_PARAMS*)pndis_req->data; 1525 devdbg(dev,"%s:connect ioctl. connect mode %d",__func__,parms->ConnectIpMode); 1526 ret = ndis_connect(g_cdc_dev,parms->AccessString,parms->UserName, 1527 parms->Password,parms->Commpression,parms->ConnectIpMode); 1528 //printk("..............\n"); 1529 copy_to_user((void *)req->ifr_data,&(ndis_status.fConnectionError),sizeof(ndis_status.fConnectionError)); 1530 } 1531 break; 1532 case NDIS_CMD_DISCONN_CMD: 1533 { 1534 devdbg(dev,"%s:disconnect ioctl.",__func__); 1535 ndis_disconnect(g_cdc_dev); 1536 } 1537 break; 1538 case NDIS_CMD_GET_VERSION: 1539 { 1540 devdbg(dev,"%s:get version ioctl.",__func__); 1541 copy_to_user((void *)req->ifr_data,ndis_status.fVersion,sizeof(ndis_status.fVersion)); 1542 } 1543 break; 1544 case NDIS_CMD_GET_STATUS: 1545 { 1546 WWAN_STATUS m_status; 1547 devdbg(dev,"%s:get status ioctl.",__func__); 1548 lc_get_qmi_status(g_cdc_dev->intf); 1549 m_status.connection_status = ndis_status.fConnectionStatus; 1550 m_status.ip_address = ndis_status.fIPAddress; 1551 copy_to_user((void *)req->ifr_data,&m_status,sizeof(WWAN_STATUS)); 1552 } 1553 break; 1554 default: 1555 devdbg(dev,"unsupport cmmmand%d.",cmd); 1556 } 1557 return 0; 1558} 1559 1560/*-------------------------------------------------------------------------*/ 1561#if !(LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 30)) 1562static int lc_eth_mac_addr(struct net_device *dev, void *p) 1563{ 1564 memcpy(dev->dev_addr,fEthernetHeader.SrcMacAddress,ETH_LENGTH_OF_ADDRESS); 1565 1566 return 0; 1567} 1568static const struct net_device_ops lc_netdev_ops = { 1569 .ndo_open = lc_open, 1570 .ndo_stop = lc_stop, 1571 .ndo_start_xmit = lc_start_xmit, 1572 .ndo_tx_timeout = lc_tx_timeout, 1573 .ndo_change_mtu = lc_change_mtu, 1574 .ndo_do_ioctl = lc_ndis_ioctl, 1575 .ndo_set_mac_address = lc_eth_mac_addr, 1576 .ndo_validate_addr = eth_validate_addr, 1577 .ndo_get_stats = lc_get_stats, 1578}; 1579#endif 1580 1581// precondition: never called in_interrupt 1582int lc_check_conn_status(struct usb_interface *intf); 1583 1584 1585int 1586lc_cdc_probe (struct usb_interface *udev, const struct usb_device_id *prod) 1587{ 1588 struct lc_cdc_net *dev; 1589 struct net_device *net; 1590 struct usb_host_interface *interface; 1591 struct usb_device *xdev; 1592 int status; 1593 const char *name; 1594// DECLARE_MAC_BUF(mac); 1595 name = udev->dev.driver->name; 1596 xdev = interface_to_usbdev (udev); 1597 interface = udev->cur_altsetting; 1598 1599 usb_get_dev (xdev); 1600 1601 status = -ENOMEM; 1602 1603 // set up our own records 1604 net = alloc_etherdev(sizeof(*dev)); 1605 if (!net) { 1606 dbg ("can't kmalloc dev"); 1607 goto out; 1608 } 1609 1610 dev = netdev_priv(net); 1611 g_cdc_dev = dev; 1612 dev->udev = xdev; 1613 dev->intf = udev; 1614/* Add for DTS2011050903736 lxz 20110520 start*/ 1615/* linux kernel > 2.6.37: PowerManager needs disable_depth ==0 */ 1616#ifdef CONFIG_PM_RUNTIME 1617 if(LINUX_VERSION37_LATER) 1618 { 1619 dev->intf->dev.power.disable_depth = 0; 1620 } 1621#endif 1622/* Add for DTS2011050903736 lxz 20110520 end*/ 1623 1624 dev->driver_name = name; 1625 dev->driver_desc = "Longcheer Ethernet Device"; 1626 dev->msg_enable = netif_msg_init (msg_level, NETIF_MSG_DRV 1627 | NETIF_MSG_PROBE | NETIF_MSG_LINK); 1628 skb_queue_head_init (&dev->rxq); 1629 skb_queue_head_init (&dev->txq); 1630 skb_queue_head_init (&dev->done); 1631 dev->bh.func = lc_bh; 1632 dev->bh.data = (unsigned long) dev; 1633 INIT_WORK (&dev->kevent, kevent); 1634 dev->delay.function = lc_bh; 1635 dev->delay.data = (unsigned long) dev; 1636 init_timer (&dev->delay); 1637 mutex_init (&dev->phy_mutex); 1638 1639 dev->net = net; 1640 //strcpy (net->name, "eth%d"); 1641 memcpy (net->dev_addr, node_id, sizeof node_id); 1642 1643 /* rx and tx sides can use different message sizes; 1644 * bind() should set rx_urb_size in that case. 1645 */ 1646 dev->hard_mtu = net->mtu + net->hard_header_len; 1647 1648#if !(LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 30)) 1649 net->netdev_ops = &lc_netdev_ops; 1650#else 1651 net->change_mtu = lc_change_mtu; 1652 net->get_stats = lc_get_stats; 1653 net->hard_start_xmit = lc_start_xmit; 1654 net->open = lc_open; 1655 net->stop = lc_stop; 1656 net->do_ioctl = lc_ndis_ioctl; 1657 net->tx_timeout = lc_tx_timeout; 1658#endif 1659 net->watchdog_timeo = TX_TIMEOUT_JIFFIES; 1660 net->ethtool_ops = &lc_ethtool_ops; 1661 1662 1663 status = lc_cdc_bind (dev, udev); 1664 if (status < 0) 1665 goto out1; 1666 1667 1668 strcpy (net->name, "wan%d"); 1669 1670// printk("%s........net->hard_header_len=%d",__func__,net->hard_header_len); 1671 /* maybe the remote can't receive an Ethernet MTU */ 1672 if (net->mtu > (dev->hard_mtu - net->hard_header_len)) 1673 net->mtu = dev->hard_mtu - net->hard_header_len; 1674 1675#ifdef NDIS_INIT_STATUS 1676 if (status >= 0 && dev->status) 1677 status = init_status (dev, udev); 1678 if (status < 0) 1679 goto out3; 1680#endif 1681 1682 dev->rx_urb_size = net->mtu; 1683 1684 dev->maxpacket = usb_maxpacket (dev->udev, dev->out, 1); 1685 devdbg(dev,"%s:dev->rx_urb_size=%u,dev->maxpacket=%u.\n",__func__,dev->rx_urb_size,dev->maxpacket); 1686 SET_NETDEV_DEV(net, &udev->dev); 1687 status = register_netdev (net); 1688 if (status) 1689 goto out3; 1690 // ok, it's ready to go. 1691 usb_set_intfdata (udev, dev); 1692 1693 netif_device_attach (net); 1694 1695 //kernel_thread(lc_check_conn_status, (void *)net, 0); 1696 1697 /*set the carrier off as default*/ 1698 netif_carrier_off(net); 1699 { 1700 dev->qmi_sync = 0; 1701 // INIT_DELAYED_WORK(&dev->status_work, lc_cdc_check_status_work); 1702 // schedule_delayed_work(&dev->status_work, 40*HZ); 1703 } 1704 //lc_check_conn_status(udev); 1705 // 1706 memset(&ndis_status,0,sizeof(ndis_status)); 1707 ndis_status.fConnectionStatus = LC_DISCONNECTED; 1708 spin_lock_init(&qmi_request_lock); 1709 return 0; 1710 1711out3: 1712 lc_cdc_unbind (dev, udev); 1713out1: 1714 free_netdev(net); 1715out: 1716 usb_put_dev(xdev); 1717 return status; 1718} 1719EXPORT_SYMBOL_GPL(lc_cdc_probe); 1720 1721/*-------------------------------------------------------------------------*/ 1722 1723/* 1724 * suspend the whole driver as soon as the first interface is suspended 1725 * resume only when the last interface is resumed 1726 */ 1727 1728int lc_suspend (struct usb_interface *intf, pm_message_t message) 1729{ 1730 struct lc_cdc_net *dev = usb_get_intfdata(intf); 1731 1732 if (!dev->suspend_count++) { 1733 /* 1734 * accelerate emptying of the rx and queues, to avoid 1735 * having everything error out. 1736 */ 1737 netif_device_detach (dev->net); 1738 (void) unlink_urbs (dev, &dev->rxq); 1739 (void) unlink_urbs (dev, &dev->txq); 1740 /* 1741 * reattach so runtime management can use and 1742 * wake the device 1743 */ 1744 netif_device_attach (dev->net); 1745 } 1746 return 0; 1747} 1748EXPORT_SYMBOL_GPL(lc_suspend); 1749 1750int lc_resume (struct usb_interface *intf) 1751{ 1752 struct lc_cdc_net *dev = usb_get_intfdata(intf); 1753 1754 if (!--dev->suspend_count) 1755 tasklet_schedule (&dev->bh); 1756 1757 return 0; 1758} 1759EXPORT_SYMBOL_GPL(lc_resume); 1760 1761static int lc_cdc_reset_resume(struct usb_interface *intf) 1762{ 1763 return lc_resume (intf); 1764} 1765/////////////////////////////////////////////////////////////////////////////////////////////////////// 1766/* 1767 * probes control interface, claims data interface, collects the bulk 1768 * endpoints, activates data interface (if needed), maybe sets MTU. 1769 * all pure cdc 1770 */ 1771//int lc_generic_cdc_bind(struct lc_cdc_net *dev, struct usb_interface *intf) 1772#define USB_DEVICE_Longcheer_DATA 0xFF 1773static int lc_cdc_bind(struct lc_cdc_net *dev, struct usb_interface *intf) 1774{ 1775// u8 *buf = intf->cur_altsetting->extra; 1776// int len = intf->cur_altsetting->extralen; 1777 1778 struct lc_dev_state *info = (void *) &dev->data; 1779 int status; 1780 1781 devdbg(dev,"lc_cdc_bind enter."); 1782 1783 if (sizeof dev->data < sizeof *info) 1784 return -EDOM; 1785 1786 if (LC_INTERFACE_INDEX != intf->cur_altsetting->desc.bInterfaceNumber) 1787 return -EDOM; 1788 1789 memcpy(fEthernetHeader.DstMacAddress, fCurMacAddress, ETH_LENGTH_OF_ADDRESS); 1790 memcpy(fEthernetHeader.SrcMacAddress, fDstMacAddress, ETH_LENGTH_OF_ADDRESS); 1791 fEthernetHeader.EtherType = htons(ETH_TYPE_IPV4); 1792 1793 memset(info, 0, sizeof *info); 1794 1795 info->data = usb_ifnum_to_if(dev->udev,intf->cur_altsetting->desc.bInterfaceNumber); 1796 1797 status = lc_get_endpoints(dev, info->data); 1798 if (status < 0) { 1799 /* ensure immediate exit from lc_disconnect */ 1800 goto error3; 1801 } 1802 1803 return lc_get_ethernet_addr(dev); 1804 1805error3: 1806 /* ensure immediate exit from cdc_disconnect */ 1807 usb_set_intfdata(info->data, NULL); 1808 usb_driver_release_interface(driver_of(intf), info->data); 1809 1810 return status; 1811 1812 devinfo(dev, "bad CDC descriptors\n"); 1813 return -ENODEV; 1814} 1815 1816void lc_cdc_unbind(struct lc_cdc_net *dev, struct usb_interface *intf) 1817{ 1818 struct lc_dev_state *info = (void *) &dev->data; 1819 struct usb_driver *driver = driver_of(intf); 1820 1821 /* disconnect master --> disconnect slave */ 1822 if (intf == info->control && info->data) { 1823 /* ensure immediate exit from usbnet_disconnect */ 1824 usb_set_intfdata(info->data, NULL); 1825 usb_driver_release_interface(driver, info->data); 1826 info->data = NULL; 1827 } 1828 1829 /* and vice versa (just in case) */ 1830 else if (intf == info->data && info->control) { 1831 /* ensure immediate exit from usbnet_disconnect */ 1832 usb_set_intfdata(info->control, NULL); 1833 usb_driver_release_interface(driver, info->control); 1834 info->control = NULL; 1835 } 1836 1837} 1838EXPORT_SYMBOL_GPL(lc_cdc_unbind); 1839 1840 1841/*------------------------------------------------------------------------- 1842 * 1843 * Communications Device Class, Ethernet Control model 1844 * 1845 * Takes two interfaces. The DATA interface is inactive till an altsetting 1846 * is selected. Configuration data includes class descriptors. There's 1847 * an optional status endpoint on the control interface. 1848 * 1849 * This should interop with whatever the 2.4 "CDCEther.c" driver 1850 * (by Brad Hards) talked with, with more functionality. 1851 * 1852 *-------------------------------------------------------------------------*/ 1853#ifdef NDIS_INIT_STATUS 1854static void dumpspeed(struct lc_cdc_net *dev, __le32 *speeds) 1855{ 1856 if (netif_msg_timer(dev)) 1857 devinfo(dev, "link speeds: %u kbps up, %u kbps down", 1858 __le32_to_cpu(speeds[0]) / 1000, 1859 __le32_to_cpu(speeds[1]) / 1000); 1860} 1861#endif 1862static inline int lc_get_ethernet_addr(struct lc_cdc_net *dev) 1863{ 1864 1865 //dev->net->dev_addr[0] = 0x00; 1866 //dev->net->dev_addr[1] = 0x1e; 1867 1868 //dev->net->dev_addr[2] = 0x10; 1869 //dev->net->dev_addr[3] = 0x1f; 1870 //dev->net->dev_addr[4] = 0x00; 1871 //dev->net->dev_addr[5] = 0x01;/*change 0x04 into 0x01 20100129*/ 1872 1873 dev->net->dev_addr[0] = 0x00; 1874 dev->net->dev_addr[1] = 0xA0; 1875 dev->net->dev_addr[2] = 0xC6; 1876 dev->net->dev_addr[3] = 0x00; 1877 dev->net->dev_addr[4] = 0x00; 1878 dev->net->dev_addr[5] = 0x00; 1879 1880 return 0; 1881} 1882 1883#define lc_CDC_OK 0 1884#define lc_CDC_FAIL -1 1885 1886#define LONGCHEER_INTERFACE_VDF \ 1887 .bInterfaceClass = 0xFF, \ 1888 .bInterfaceSubClass = 0xFF, \ 1889 .bInterfaceProtocol = 0xFF 1890 1891#define LONGCHEER_INTERFACE_RMNET_VDF \ 1892 .bInterfaceClass = 0xFF, \ 1893 .bInterfaceSubClass = 0x06, \ 1894 .bInterfaceProtocol = 0x00 1895 1896static const struct usb_device_id lc_products [] = { 1897 { 1898 .match_flags = USB_DEVICE_ID_MATCH_INT_INFO 1899 | USB_DEVICE_ID_MATCH_VENDOR, 1900 .idVendor = 0X1C9E, 1901 LONGCHEER_INTERFACE_VDF, 1902 }, 1903 { 1904 .match_flags = USB_DEVICE_ID_MATCH_INT_INFO 1905 | USB_DEVICE_ID_MATCH_VENDOR, 1906 .idVendor = 0X05c6, 1907 LONGCHEER_INTERFACE_VDF, 1908 }, 1909 { 1910 .match_flags = USB_DEVICE_ID_MATCH_INT_INFO 1911 | USB_DEVICE_ID_MATCH_VENDOR, 1912 .idVendor = 0X1C9E, 1913 LONGCHEER_INTERFACE_RMNET_VDF, 1914 }, 1915 { }, // END 1916}; 1917MODULE_DEVICE_TABLE(usb, lc_products); 1918 1919static int lc_cdc_reset_resume(struct usb_interface *intf); 1920static struct usb_driver lc_ether_driver = { 1921 .name = "lc_ether", 1922 .id_table = lc_products, 1923 .probe = lc_cdc_probe, 1924 .disconnect = lc_disconnect, 1925 .suspend = lc_suspend, 1926 .resume = lc_resume, 1927#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26) 1928 .reset_resume = lc_cdc_reset_resume, 1929#endif 1930}; 1931#ifdef NDIS_INIT_STATUS 1932 1933static void lc_cdc_status(struct lc_cdc_net *dev, struct urb *urb) 1934{ 1935 struct usb_cdc_notification *event; 1936 1937 if (urb->actual_length < sizeof *event) 1938 return; 1939 1940 /* SPEED_CHANGE can get split into two 8-byte packets */ 1941 if (test_and_clear_bit(EVENT_STS_SPLIT, &dev->flags)) { 1942 devdbg(dev, "The speed is changed by status event"); 1943 dumpspeed(dev, (__le32 *) urb->transfer_buffer); 1944 return; 1945 } 1946 1947 event = urb->transfer_buffer; 1948 switch (event->bNotificationType) { 1949 case USB_CDC_NOTIFY_NETWORK_CONNECTION: 1950 if (netif_msg_timer(dev)) 1951 devdbg(dev, "CDC: carrier %s", 1952 event->wValue ? "on" : "off"); 1953 if (event->wValue) 1954 netif_carrier_on(dev->net); 1955 else 1956 netif_carrier_off(dev->net); 1957 1958 break; 1959 case USB_CDC_NOTIFY_SPEED_CHANGE: /* tx/rx rates */ 1960 if (netif_msg_timer(dev)) 1961 devdbg(dev, "CDC: speed change (len %d)", 1962 urb->actual_length); 1963 if (urb->actual_length != (sizeof *event + 8)) 1964 set_bit(EVENT_STS_SPLIT, &dev->flags); 1965 else 1966 dumpspeed(dev, (__le32 *) &event[1]); 1967 break; 1968 1969 case USB_CDC_NOTIFY_RESPONSE_AVAILABLE: 1970 { 1971 break; 1972 } 1973 1974 default: 1975 devdbg(dev, "%s: CDC: unexpected notification %02x!", __FUNCTION__, 1976 event->bNotificationType); 1977 break; 1978 } 1979} 1980#endif 1981 1982static int __init lc_cdc_init(void) 1983{ 1984 BUG_ON((sizeof(((struct lc_cdc_net *)0)->data) 1985 < sizeof(struct lc_dev_state))); 1986 1987 return usb_register(&lc_ether_driver); 1988} 1989fs_initcall(lc_cdc_init); 1990 1991static int lc_send_qmi_request(struct usb_interface *intf, UInt8 reqesy_type, 1992 UInt8 *snd_req, int snd_len, 1993 UInt8 *read_resp, int resp_len); 1994 1995static int ndis_get_client_ID(struct lc_cdc_net *dev) 1996{ 1997 UInt8 command_buf[128] = {0}; 1998 UInt8 resp_buf[128] = {0}; 1999 int ret = 0; 2000 int len = 0; 2001 2002 len = QCTL_GetClientID(command_buf,sizeof(command_buf),0x01); 2003 if(len>0) 2004 { 2005 ret = lc_send_qmi_request(dev->intf,QMI_GET_CLIENT_ID,command_buf, len, resp_buf, 64); 2006 } 2007 2008 if (QMI_GET_CLIENT_ID != ret){ 2009 printk(KERN_ERR "%s: Get client ID failed\n", __FUNCTION__); 2010 return -1; 2011 } 2012 return 0; 2013} 2014static int ndis_get_version_info(struct lc_cdc_net *dev) 2015{ 2016 UInt8 command_buf[128] = {0}; 2017 UInt8 resp_buf[128] = {0}; 2018 int ret = 0; 2019 int len = 0; 2020 2021 memset(resp_buf, 0, sizeof(resp_buf)); 2022 len = QCTL_GetVersionReq(command_buf,sizeof(command_buf)); 2023 if(len>0) 2024 { 2025 ret = lc_send_qmi_request(dev->intf,QMI_GET_VERSION,command_buf, len, resp_buf, sizeof(resp_buf)); 2026 } 2027 2028 if (0 > ret){ 2029 printk(KERN_ERR "%s: Get version failed\n", __FUNCTION__); 2030 return -1; 2031 } 2032 return 0; 2033} 2034static int ndis_set_instance_ID(struct lc_cdc_net *dev) 2035{ 2036 UInt8 command_buf[128] = {0}; 2037 UInt8 resp_buf[128] = {0}; 2038 int ret = 0; 2039 int len = 0; 2040 2041 memset(resp_buf, 0, sizeof(resp_buf)); 2042 len = QCTL_SetInstanceId(command_buf,sizeof(command_buf)); 2043 if(len>0) 2044 { 2045 ret = lc_send_qmi_request(dev->intf,QMI_SET_INSTANCE,command_buf, len, resp_buf, sizeof(resp_buf)); 2046 } 2047 2048 if (0 > ret){ 2049 printk(KERN_ERR "%s: Set Instance ID failed\n", __FUNCTION__); 2050 return -1; 2051 } 2052 return 0; 2053} 2054static int ndis_set_data_format(struct lc_cdc_net *dev) 2055{ 2056 UInt8 command_buf[128] = {0}; 2057 UInt8 resp_buf[128] = {0}; 2058 int ret = 0; 2059 int len = 0; 2060 2061 //memset(resp_buf, 0, sizeof(resp_buf)); 2062 len = QCTL_SetDataFormatReq(command_buf,sizeof(command_buf)); 2063 if(len>0) 2064 { 2065 ret = lc_send_qmi_request(dev->intf,QMI_SET_DATA_FORMAT,command_buf, len, resp_buf, sizeof(resp_buf)); 2066 } 2067 2068 if (0 > ret){ 2069 printk(KERN_ERR "%s: set data format failed\n", __func__); 2070 return -1; 2071 } 2072 return 0; 2073} 2074 2075static int ndis_release_client_ID(struct lc_cdc_net *dev) 2076{ 2077 UInt8 command_buf[128] = {0}; 2078 UInt8 resp_buf[128] = {0}; 2079 int ret = 0; 2080 int len = 0; 2081 2082 //memset(resp_buf, 0, sizeof(resp_buf)); 2083 len = QCTL_ReleaseClientID(command_buf,sizeof(command_buf),&ndis_status); 2084 if(len>0) 2085 { 2086 ret = lc_send_qmi_request(dev->intf,QMI_RELEASE_CLIENT_ID,command_buf, len, resp_buf, sizeof(resp_buf)); 2087 } 2088 2089 if (0 > ret){ 2090 printk(KERN_ERR "%s: release client ID failed\n", __FUNCTION__); 2091 return -1; 2092 } 2093 return 0; 2094} 2095 2096static int ndis_connect(struct lc_cdc_net *dev,char *accessString, 2097 char *userName, 2098 char *passWord, 2099 UInt8 compression, 2100 UInt32 ConnectIpMode) 2101{ 2102 UInt8 command_buf[128] = {0}; 2103 UInt8 resp_buf[256] = {0}; 2104 int ret = 0; 2105 int len = 0; 2106 ndis_status.fConnectionError = -1; 2107 2108 //ConnectIpMode = 2; //for debug 2109 2110 memset(command_buf, 0, sizeof(command_buf)); 2111 len = QC_WDS_ModifyProfile(command_buf,sizeof(command_buf),&ndis_status, 2112 accessString,userName,passWord,compression, 2113 ConnectIpMode); 2114 if(len>0) 2115 { 2116 ret = lc_send_qmi_request(dev->intf,QMI_MODIFY_PRO,command_buf, len, resp_buf, sizeof(resp_buf)); 2117 } 2118 2119 if( ConnectIpMode == 2) 2120 { 2121 memset(command_buf, 0, 128); 2122 memset(resp_buf, 0, 256); 2123 devdbg(dev,"%s:connect ioctl. connect ipv4",__func__); 2124 len = QC_WDS_Connect(command_buf,sizeof(command_buf),ndis_status.fClientID, 2125 accessString,userName,passWord,compression,IPv4); //ipv 4 2126 if(len>0) 2127 { 2128 ret = lc_send_qmi_request(dev->intf,QMI_CONNECT,command_buf, len, resp_buf, sizeof(resp_buf)); 2129 } 2130 2131 memset(command_buf, 0, 128); 2132 memset(resp_buf, 0, 256); 2133 devdbg(dev,"%s:connect ioctl. connect ipv6",__func__); 2134 len = QC_WDS_Connect(command_buf,sizeof(command_buf),ndis_status.fClientID, 2135 accessString,userName,passWord,compression,IPv6); //ipv 6 2136 if(len>0) 2137 { 2138 ret = lc_send_qmi_request(dev->intf,QMI_CONNECT,command_buf, len, resp_buf, sizeof(resp_buf)); 2139 } 2140 2141 } 2142 else 2143 { 2144 //memset(command_buf, 0, 128); 2145 2146 devdbg(dev,"%s:connect ioctl. connect ipv4 or ipv6",__func__); 2147 len = QC_WDS_Connect(command_buf,sizeof(command_buf),ndis_status.fClientID, 2148 accessString,userName,passWord,compression,ConnectIpMode); 2149 if(len>0) 2150 { 2151 ret = lc_send_qmi_request(dev->intf,QMI_CONNECT,command_buf, len, resp_buf, sizeof(resp_buf)); 2152 } 2153 } 2154 2155 2156 if (ret < 0) 2157 { 2158 return -2; 2159 } 2160 ret = ndis_get_ip_addr(dev); 2161 return ret; 2162} 2163 2164static int ndis_get_ip_addr(struct lc_cdc_net *dev) 2165{ 2166 UInt8 command_buf[128] = {0}; 2167 UInt8 resp_buf[256] = {0}; 2168 int ret = 0; 2169 int len = 0; 2170 2171 ndis_status.fIPAddress = 0; 2172 ndis_status.fConnectionError = 0; 2173 //memset(resp_buf, 0, sizeof(resp_buf)); 2174 len = QC_WDS_GetIPAddress(command_buf,sizeof(command_buf),ndis_status.fClientID); 2175 if(len>0) 2176 { 2177 ret = lc_send_qmi_request(dev->intf,QMI_GET_IP_ADDR,command_buf, len, resp_buf, sizeof(resp_buf)); 2178 } 2179 2180 if (ret < 0) 2181 { 2182 printk("failed to get ip address.\n"); 2183 return -1; 2184 } 2185 2186 /////////////////////////enable network.... 2187 printk(KERN_ERR "%s: carrier on\n", __func__); 2188 netif_carrier_on(dev->net); 2189 2190 return 0; 2191} 2192static int ndis_disconnect(struct lc_cdc_net *dev) 2193{ 2194 UInt8 command_buf[128] = {0}; 2195 UInt8 resp_buf[128] = {0}; 2196 int ret = 0; 2197 int len = 0; 2198 2199 if(!ndis_status.fPacketHandle) 2200 { 2201 memset(command_buf, 0, sizeof(command_buf)); 2202 memset(resp_buf, 0, sizeof(resp_buf)); 2203 len = QC_WDS_Disconnect(command_buf,sizeof(command_buf),&ndis_status,0); 2204 if(len>0) 2205 { 2206 ret = lc_send_qmi_request(dev->intf,QMI_DISCONNECT,command_buf, len, resp_buf, sizeof(resp_buf)); 2207 } 2208 } 2209 if (!ndis_status.fPacketHandle1) 2210 { 2211 memset(command_buf, 0, sizeof(command_buf)); 2212 memset(resp_buf, 0, sizeof(resp_buf)); 2213 len = QC_WDS_Disconnect(command_buf,sizeof(command_buf),&ndis_status,1); 2214 if(len>0) 2215 { 2216 ret = lc_send_qmi_request(dev->intf,QMI_DISCONNECT,command_buf, len, resp_buf, sizeof(resp_buf)); 2217 } 2218 } 2219 2220 /*if (0 > ret){ 2221 printk(KERN_ERR "%s: set data format failed\n", __FUNCTION__); 2222 return -1; 2223 }*/ 2224 return 0; 2225} 2226//int lc_check_conn_status(struct usb_interface *intf) 2227static void lc_cdc_check_status_work() 2228{ 2229 //struct lc_cdc_net *net = usb_get_intfdata(intf); 2230 //usb_device *udev = interface_to_usbdev(intf); 2231 struct lc_cdc_net *dev = g_cdc_dev; 2232 2233 int ret = 0; 2234// int repeat = 0; 2235 2236 2237 // status_req[5] = resp_buf[23]; 2238 2239 //////////////////////////get version 2240 ret = ndis_get_version_info(dev); 2241 if(-1 == ret) 2242 { 2243 goto failed; 2244 } 2245 msleep(80); 2246 //////////////////////////set instance ID 2247 ret = ndis_set_instance_ID(dev); 2248 if(-1 == ret) 2249 { 2250 goto failed; 2251 } 2252 msleep(80); 2253 //////////////////////////set data format 2254 ret = ndis_set_data_format(dev); 2255 if(-1 == ret) 2256 { 2257 goto failed; 2258 } 2259 msleep(80); 2260 //////////////////////////get client id 2261 ret = ndis_get_client_ID(dev); 2262 if(-1 == ret) 2263 { 2264 goto failed; 2265 } 2266// printk(KERN_ERR"%s: carrier on\n", __FUNCTION__); 2267// netif_carrier_on(dev->net); 2268failed: 2269 2270 dev->qmi_sync = 1; 2271// cancel_delayed_work(&dev->status_work); 2272 return; 2273} 2274 2275static int lc_get_qmi_status(struct usb_interface *intf) 2276{ 2277 UInt8 read_resp[128]; 2278 int resp_len = sizeof(read_resp); 2279 struct usb_device *udev = interface_to_usbdev(intf); 2280 int ret = -1; 2281 int index = 0; 2282 2283 while(index++ < 3) 2284 { 2285 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x01, 2286 0xA1, 0x00, intf->cur_altsetting->desc.bInterfaceNumber, 2287 read_resp, resp_len, 1000); 2288 devdbg(g_cdc_dev,"get qmi response:"); 2289 2290 if (ret <= 0) 2291 { 2292 msleep(10); 2293 } else 2294 { 2295 printk_hex(read_resp,resp_len); 2296 ret = processQMIResponse((void*)read_resp,&ndis_status); 2297 if (QMI_CONNECT == ret) 2298 { 2299 if( 0 == ndis_status.fConnectionError) 2300 { 2301 devdbg(g_cdc_dev,"connect to internet success."); 2302 ndis_status.fConnectionStatus = LC_GETTING_IP; 2303 ndis_get_ip_addr(g_cdc_dev); 2304 }else 2305 { 2306 devdbg(g_cdc_dev,"connecting to internet failed."); 2307 ndis_status.fConnectionStatus = LC_DISCONNECTED; 2308 } 2309 } 2310 if (QMI_DISCONNECT == ret) 2311 { 2312 devdbg(g_cdc_dev,"disconnected from internet success."); 2313 ndis_status.fConnectionStatus = LC_DISCONNECTED; 2314 return ret; 2315 } 2316 if(QMI_GET_IP_ADDR == ret) 2317 { 2318 if( 0 == ndis_status.fConnectionError && 0 != ndis_status.fIPAddress) 2319 { 2320 devdbg(g_cdc_dev,"connect to internet success."); 2321 ndis_status.fConnectionStatus = LC_IP_GETTED; 2322 }else 2323 { 2324 devdbg(g_cdc_dev,"connecting to internet failed."); 2325 ndis_status.fConnectionStatus = LC_DISCONNECTED; 2326 } 2327 } 2328 ret = 0; 2329 } 2330 } 2331 if(index==3) 2332 devdbg(g_cdc_dev,"%s: nothing qmi response ...\n", __func__); 2333 2334 return ret; 2335} 2336 2337static int lc_send_qmi_request(struct usb_interface *intf, UInt8 reqesy_type, 2338 UInt8 *snd_req, int snd_len, 2339 UInt8 *read_resp, int resp_len) 2340{ 2341 int ret; 2342 int index = 0; 2343// int len = 0; 2344 unsigned long flags; 2345 struct usb_device *udev = interface_to_usbdev(intf); 2346// struct lc_cdc_net *net = usb_get_intfdata(intf); 2347// spin_lock_irqsave (&qmi_request_lock, flags); 2348 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x00, 2349 0x21, 0x00, intf->cur_altsetting->desc.bInterfaceNumber, 2350 snd_req, snd_len, 5000); 2351 devdbg(g_cdc_dev,"send qmi request: %d ",ret); 2352 printk_hex(snd_req,snd_len); 2353 if (ret < 0){ 2354 printk(KERN_ERR"%s: send the qmi request failed\n", __FUNCTION__); 2355// spin_unlock_irqrestore (&qmi_request_lock, flags); 2356 return ret; 2357 } 2358 msleep(80); 2359 switch(reqesy_type) 2360 { 2361 case QMI_GET_CLIENT_ID: 2362 while(index++ < 10) 2363 { 2364 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x01, 2365 0xA1, 0x00, intf->cur_altsetting->desc.bInterfaceNumber, 2366 read_resp, resp_len, 1000); 2367 devdbg(g_cdc_dev,"get qmi response:"); 2368 2369 if (ret <= 0) 2370 { 2371 // printk(KERN_ERR"%s: Get response failed.\n", __func__); 2372 msleep(10); 2373 } else 2374 { 2375 printk_hex(read_resp,resp_len); 2376 ret = processQMIResponse((void*)read_resp,&ndis_status); 2377 if (QMI_GET_CLIENT_ID == ret) 2378 { 2379 devdbg(g_cdc_dev,"get qmi ClientID response success.clientid=%u:\n",ndis_status.fClientID); 2380// spin_unlock_irqrestore (&qmi_request_lock, flags); 2381 return ret; 2382 } 2383 } 2384 } 2385 devdbg(g_cdc_dev,"%s: Get response timeout.", __func__); 2386 ret = -2; 2387 break; 2388 case QMI_RELEASE_CLIENT_ID: 2389 while(index++ < 10) 2390 { 2391 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x01, 2392 0xA1, 0x00, intf->cur_altsetting->desc.bInterfaceNumber, 2393 read_resp, resp_len, 1000); 2394 devdbg(g_cdc_dev,"get qmi response:"); 2395 2396 if (ret <= 0) 2397 { 2398 // printk(KERN_ERR"%s: Get response failed.", __func__); 2399 msleep(10); 2400 } else 2401 { 2402 // printk_hex(read_resp,resp_len); 2403 ret = processQMIResponse((void*)read_resp,&ndis_status); 2404 if (QMI_RELEASE_CLIENT_ID == ret) 2405 { 2406 devdbg(g_cdc_dev,"Release qmi ClientID success.clientid=%u:",ndis_status.fClientID); 2407// spin_unlock_irqrestore (&qmi_request_lock, flags); 2408 return ret; 2409 } 2410 } 2411 } 2412 devdbg(g_cdc_dev,"%s: Get response timeout.", __func__); 2413 ret = -2; 2414 break; 2415 case QMI_CONNECT: 2416 ndis_status.fConnectionStatus = LC_CONNECTING; 2417 while(index++ < 50) 2418 { 2419 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x01, 2420 0xA1, 0x00, intf->cur_altsetting->desc.bInterfaceNumber, 2421 read_resp, resp_len, 1000); 2422 devdbg(g_cdc_dev,"get QMI_CONNECT response,index=%d:",index); 2423 2424 if (ret <= 0) 2425 { 2426 // printk(KERN_ERR"%s: Get QMI_CONNECT response failed\n", __func__); 2427 msleep(100); 2428 } else 2429 { 2430 printk_hex(read_resp,resp_len); 2431 ret = processQMIResponse((void*)read_resp,&ndis_status); 2432 if (QMI_CONNECT == ret) 2433 { 2434// spin_unlock_irqrestore (&qmi_request_lock, flags); 2435 if( 0 == ndis_status.fConnectionError) 2436 { 2437 devdbg(g_cdc_dev,"connect to internet success."); 2438 ndis_status.fConnectionStatus = LC_GETTING_IP; 2439 return 0; 2440 }else 2441 { 2442 devdbg(g_cdc_dev,"connect to internet failed."); 2443 ndis_status.fConnectionStatus = LC_DISCONNECTED; 2444 return -1; 2445 } 2446 } 2447 } 2448 } 2449 devdbg(g_cdc_dev,"%s: Get response timeout.", __func__); 2450 ret = -2; 2451 break; 2452 case QMI_DISCONNECT: 2453 while(index++ < 10) 2454 { 2455 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x01, 2456 0xA1, 0x00, intf->cur_altsetting->desc.bInterfaceNumber, 2457 read_resp, resp_len, 1000); 2458 printk("get QMI_DISCONNECT response,index=%d:\n",index); 2459 2460 if (ret <= 0) 2461 { 2462 printk(KERN_ERR"%s: Get QMI_DISCONNECT response failed\n", __func__); 2463 msleep(10); 2464 } else 2465 { 2466 printk_hex(read_resp,resp_len); 2467 ret = processQMIResponse((void*)read_resp,&ndis_status); 2468 spin_unlock_irqrestore (&qmi_request_lock, flags); 2469 if (QMI_DISCONNECT == ret) 2470 { 2471 printk("call QMI_DISCONNECT success.\n"); 2472 return ret; 2473 } 2474 } 2475 } 2476 ndis_status.fConnectionStatus = LC_DISCONNECTING; 2477 ret = -2; 2478 break; 2479 case QMI_GET_IP_ADDR: 2480 #if 0 2481 while(index++ < 20) 2482 { 2483 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x01, 2484 0xA1, 0x00, intf->cur_altsetting->desc.bInterfaceNumber, 2485 read_resp, resp_len, 3000); 2486 // devdbg(g_cdc_dev,"get QMI_GET_IP_ADDR response,index=%d:",index); 2487 2488 if (ret <= 0) 2489 { 2490 // printk(KERN_ERR"%s: Get QMI_GET_IP_ADDR response failed\n", __func__); 2491 msleep(100); 2492 }else 2493 { 2494 // printk_hex(read_resp,resp_len); 2495 ret = processQMIResponse((void*)read_resp,&ndis_status); 2496 if (QMI_GET_IP_ADDR == ret ) 2497 { 2498 // spin_unlock_irqrestore (&qmi_request_lock, flags); 2499 if(0 == ndis_status.fConnectionError) 2500 { 2501 // devdbg(g_cdc_dev,"get ipaddress success.ipaddress:%u",ndis_status.fIPAddress); 2502 //ndis_status.fConnectionStatus = NDIS_CONNECTED; 2503 return 0; 2504 }else 2505 { 2506 // devdbg(g_cdc_dev,"get ipaddress failed.error num:%u",ndis_status.fConnectionError); 2507 //ndis_status.fConnectionStatus = NDIS_DISCONNECTED; 2508 return -1; 2509 } 2510 } 2511 } 2512 } 2513 // devdbg(g_cdc_dev,"%s: Get response timeout.", __func__); 2514 ret = -2; 2515 #endif 2516 break; 2517 case QMI_SET_DATA_FORMAT: 2518 while(index++ < 10) 2519 { 2520 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x01, 2521 0xA1, 0x00, intf->cur_altsetting->desc.bInterfaceNumber, 2522 read_resp, resp_len, 1000); 2523 devdbg(g_cdc_dev,"get qmi response:"); 2524 printk_hex(read_resp,resp_len); 2525 if (ret <= 0) 2526 { 2527 msleep(10); 2528 } else 2529 { 2530 ret = processQMIResponse((void*)read_resp,&ndis_status); 2531 if (QMI_SET_DATA_FORMAT == ret) 2532 { 2533 devdbg(g_cdc_dev,"get Set data format success."); 2534// spin_unlock_irqrestore (&qmi_request_lock, flags); 2535 return ret; 2536 } 2537 } 2538 } 2539 devdbg(g_cdc_dev,"%s: Get response timeout.", __func__); 2540 ret = -2; 2541 break; 2542 case QMI_MODIFY_PRO: 2543 while(index++ < 10) 2544 { 2545 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x01, 2546 0xA1, 0x00, intf->cur_altsetting->desc.bInterfaceNumber, 2547 read_resp, resp_len, 1000); 2548 devdbg(g_cdc_dev,"get qmi response:"); 2549 //printk_hex(read_resp,resp_len); 2550 2551 if (ret < 0) 2552 { 2553 printk(KERN_ERR"%s: Set Instance failed. %d", __func__,ret); 2554 msleep(10); 2555 } else 2556 { 2557 ret = processQMIResponse((void*)read_resp,&ndis_status); 2558 if (QMI_MODIFY_PRO == ret) 2559 { 2560 devdbg(g_cdc_dev,"get QMI_MODIFY_PRO success."); 2561// spin_unlock_irqrestore (&qmi_request_lock, flags); 2562 return ret; 2563 } 2564 } 2565 } 2566 devdbg(g_cdc_dev,"%s: Get response timeout.", __func__); 2567 ret = -2; 2568 break; 2569 2570 case QMI_SET_INSTANCE: 2571 while(index++ < 10) 2572 { 2573 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x01, 2574 0xA1, 0x00, intf->cur_altsetting->desc.bInterfaceNumber, 2575 read_resp, resp_len, 1000); 2576 devdbg(g_cdc_dev,"get qmi response:"); 2577 printk_hex(read_resp,resp_len); 2578 if (ret <= 0) 2579 { 2580 //printk(KERN_ERR"%s: Set Instance failed.", __func__); 2581 msleep(10); 2582 } else 2583 { 2584 ret = processQMIResponse((void*)read_resp,&ndis_status); 2585 if (QMI_SET_INSTANCE == ret) 2586 { 2587 devdbg(g_cdc_dev,"get Set Instance response success."); 2588// spin_unlock_irqrestore (&qmi_request_lock, flags); 2589 return ret; 2590 } 2591 } 2592 } 2593 devdbg(g_cdc_dev,"%s: Get response timeout.", __func__); 2594 ret = -2; 2595 break; 2596 case QMI_GET_VERSION: 2597 while(index++ < 10) 2598 { 2599// char version[64]={0}; 2600 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x01, 2601 0xA1, 0x00, intf->cur_altsetting->desc.bInterfaceNumber, 2602 read_resp, resp_len, 1000); 2603 devdbg(g_cdc_dev,"get qmi response:"); 2604 printk_hex(read_resp,resp_len); 2605 if (ret <= 0) 2606 { 2607 //printk(KERN_ERR"%s: Get version failed\n", __func__); 2608 msleep(10); 2609 } else 2610 { 2611 ret = processQMIResponse((void*)read_resp,&ndis_status); 2612 if (QMI_GET_VERSION == ret) 2613 { 2614 devdbg(g_cdc_dev,"get qmi version success.version:%s.",ndis_status.fVersion); 2615// spin_unlock_irqrestore (&qmi_request_lock, flags); 2616 return ret; 2617 } 2618 } 2619 } 2620 devdbg(g_cdc_dev,"%s: Get response timeout.", __func__); 2621 ret = -2; 2622 break; 2623 default: 2624 devdbg(g_cdc_dev,"unknown qmi request type:"); 2625 break; 2626 } 2627 2628// spin_unlock_irqrestore (&qmi_request_lock, flags); 2629 return ret; 2630} 2631 2632static void __exit lc_cdc_exit(void) 2633{ 2634 usb_deregister(&lc_ether_driver); 2635} 2636module_exit(lc_cdc_exit); 2637 2638 2639MODULE_AUTHOR(DRIVER_AUTHOR); 2640MODULE_DESCRIPTION(DRIVER_DESC); 2641MODULE_VERSION(DRIVER_VERSION); 2642MODULE_LICENSE("GPL"); 2643