static int baseband_usb_driver_resume(struct usb_interface *intf)
{
int i, err;
pr_debug("%s intf %p\n", __func__, intf);
for (i = 0; i < max_intfs; i++) {
pr_debug("[%d]\n", i);
if (!baseband_usb_net[i])
continue;
if (baseband_usb_net[i]->usb.interface != intf) {
pr_debug("%p != %p\n",
baseband_usb_net[i]->usb.interface, intf);
continue;
}
/* start usb rx */
if (baseband_usb_net[i]->usb.rx_urb) {
pr_debug("rx_usb already exists\n");
continue;
}
err = usb_net_raw_ip_rx_urb_submit(baseband_usb_net[i]);
if (err < 0) {
pr_err("submit rx failed - err %d\n", err);
continue;
}
}
return 0;
}
static int baseband_usb_driver_resume(struct usb_interface *intf)
{
int i, err;
pr_debug("%s intf %p\n", __func__, intf);
// i = intf->cur_altsetting->desc.bInterfaceNumber;
// i = (i-1)/2;
for (i = 0; i < MAX_INTFS; i++)
{
pr_debug("[%d]\n", i);
if (!baseband_usb_net[i])
continue;
if (baseband_usb_net[i]->usb.interface != intf) {
pr_debug("%p != %p\n",
baseband_usb_net[i]->usb.interface, intf);
continue;
}
if (baseband_usb_net[i]->usb.rx_urb) {
pr_debug("rx_usb already exists\n");
continue;
}
/* start usb rx */
err = usb_net_raw_ip_rx_urb_submit(baseband_usb_net[i]);
if (err < 0) {
pr_err("submit rx failed - err %d\n", err);
continue;
}
}
return 0;
}
static int baseband_usb_driver_resume(struct usb_interface *intf)
{
int i, err, susp_count;
pr_debug("%s intf %p\n", __func__, intf);
#ifdef CONFIG_PM_RUNTIME
pr_debug("%s: cnt %d intf=%p &intf->dev=%p kobj=%s\n",
__func__, atomic_read(&intf->dev.power.usage_count),
intf, &intf->dev, kobject_name(&intf->dev.kobj));
#endif
for (i = 0; i < max_intfs; i++) {
pr_debug("[%d]\n", i);
if (!baseband_usb_net[i])
continue;
if (baseband_usb_net[i]->usb.interface != intf) {
pr_debug("%p != %p\n",
baseband_usb_net[i]->usb.interface, intf);
continue;
}
/* decrement suspend count */
susp_count = --(baseband_usb_net[i]->susp_count);
if (susp_count > 0) {
pr_debug("%s: susp_count %d > 0 (not resuming yet)\n",
__func__, susp_count);
continue;
}
if (susp_count < 0) {
pr_debug("%s: susp_count %d < 0 (ILLEGAL VALUE)\n",
__func__, susp_count);
baseband_usb_net[i]->susp_count = 0;
continue;
}
pr_debug("%s: susp_count = %d (resuming...)\n",
__func__, susp_count);
/* acquire semaphore */
if (down_interruptible(&baseband_usb_net[i]->sem)) {
pr_err("%s: cannot acquire semaphore\n", __func__);
continue;
}
/* start usb rx */
err = usb_net_raw_ip_rx_urb_submit(baseband_usb_net[i]);
if (err < 0) {
pr_err("submit rx failed - err %d\n", err);
up(&baseband_usb_net[i]->sem);
continue;
}
/* restart tx urb work (cancelled in suspend) */
if (!baseband_usb_net[i]->usb.tx_workqueue) {
pr_err("%s: !tx_workqueue\n", __func__);
up(&baseband_usb_net[i]->sem);
continue;
}
queue_work(baseband_usb_net[i]->usb.tx_workqueue,
&baseband_usb_net[i]->usb.tx_work);
/* release semaphore */
up(&baseband_usb_net[i]->sem);
}
return 0;
}
static int baseband_usb_driver_probe(struct usb_interface *intf,
const struct usb_device_id *id)
{
// int i = g_i;
int i;
int err =0;
pr_debug("%s(%d) { intf %p id %p\n", __func__, __LINE__, intf, id);
pr_debug("i %d\n", i);
pr_debug("intf->cur_altsetting->desc.bInterfaceNumber %02x\n",
intf->cur_altsetting->desc.bInterfaceNumber);
pr_debug("intf->cur_altsetting->desc.bAlternateSetting %02x\n",
intf->cur_altsetting->desc.bAlternateSetting);
pr_debug("intf->cur_altsetting->desc.bNumEndpoints %02x\n",
intf->cur_altsetting->desc.bNumEndpoints);
pr_debug("intf->cur_altsetting->desc.bInterfaceClass %02x\n",
intf->cur_altsetting->desc.bInterfaceClass);
pr_debug("intf->cur_altsetting->desc.bInterfaceSubClass %02x\n",
intf->cur_altsetting->desc.bInterfaceSubClass);
pr_debug("intf->cur_altsetting->desc.bInterfaceProtocol %02x\n",
intf->cur_altsetting->desc.bInterfaceProtocol);
pr_debug("intf->cur_altsetting->desc.iInterface %02x\n",
intf->cur_altsetting->desc.iInterface);
/*
if (g_usb_interface_index[i] !=
intf->cur_altsetting->desc.bInterfaceNumber) {
pr_debug("%s(%d) } -ENODEV\n", __func__, __LINE__);
return -ENODEV;
} else {
g_usb_interface[i] = intf;
}*/
for (i = 0; i < MAX_INTFS; i++)
{
if(intf->cur_altsetting->desc.bInterfaceNumber == usb_net_raw_ip_intf[i] )
{
g_usb_interface[i] = intf;
break;
}
}
printk("\n**********wjp********* %d \n",i);
if(i >= MAX_INTFS )
{
printk("the current interface number is %d",intf->cur_altsetting->desc.bInterfaceNumber);
return -ENODEV;
}
baseband_usb_open(baseband_usb_net[i],i, usb_net_raw_ip_intf[i]);
/* start usb rx */
err = usb_net_raw_ip_rx_urb_submit(baseband_usb_net[i]);
if (err < 0) {
pr_err("submit rx failed - err %d\n", err);
// goto error_exit;
}
pr_debug("%s(%d) }\n", __func__, __LINE__);
return 0;
}
static void usb_net_raw_ip_rx_urb_comp(struct urb *urb)
{
struct baseband_usb *usb = (struct baseband_usb *) urb->context;
int i = usb->baseband_index;
struct sk_buff *skb;
unsigned char *dst;
unsigned char ethernet_header[14] = {
/* Destination MAC */
0x00, 0x00,
0x00, 0x00,
0x00, 0x00,
/* Source MAC */
0x00, 0x00,
0x00, 0x00,
0x00, 0x00,
/* EtherType */
NET_IP_ETHERTYPE,
};
pr_debug("usb_net_raw_ip_rx_urb_comp { urb %p\n", urb);
/* check input */
if (!urb) {
pr_err("no urb\n");
return;
}
if (urb->status == -ENOENT) {
pr_info("rx urb killed\n");
return;
}
if (urb->status) {
pr_info("rx urb status %d\n", urb->status);
}
/* put rx urb data in rx buffer */
if (urb->actual_length) {
pr_debug("usb_net_raw_ip_rx_urb_comp - "
"urb->actual_length %d\n", urb->actual_length);
/* allocate skb with space for
* - dummy ethernet header
* - rx IP packet from modem
*/
skb = netdev_alloc_skb(usb_net_raw_ip_dev[i],
NET_IP_ALIGN + 14 + urb->actual_length);
if (skb) {
/* generate a dummy ethernet header
* since modem sends IP packets without
* any ethernet headers
*/
memcpy(ethernet_header + 0,
usb_net_raw_ip_dev[i]->dev_addr, 6);
memcpy(ethernet_header + 6,
"0x01\0x02\0x03\0x04\0x05\0x06", 6);
/* fill skb with
* - dummy ethernet header
* - rx IP packet from modem
*/
skb_reserve(skb, NET_IP_ALIGN);
dst = skb_put(skb, 14);
memcpy(dst, ethernet_header, 14);
dst = skb_put(skb, urb->actual_length);
memcpy(dst, urb->transfer_buffer, urb->actual_length);
skb->protocol = eth_type_trans(skb,
usb_net_raw_ip_dev[i]);
/* pass skb to network stack */
if (netif_rx(skb) < 0) {
pr_err("usb_net_raw_ip_rx_urb_comp_work - "
"netif_rx(%p) failed\n", skb);
kfree_skb(skb);
}
} else {
pr_err("usb_net_raw_ip_rx_urb_comp_work - "
"netdev_alloc_skb() failed\n");
}
}
/* free rx urb */
if (urb->transfer_buffer) {
kfree(urb->transfer_buffer);
urb->transfer_buffer = (void *) 0;
}
usb_free_urb(urb);
usb->usb.rx_urb = (struct urb *) 0;
/* submit next rx urb */
usb_net_raw_ip_rx_urb_submit(usb);
pr_debug("usb_net_raw_ip_rx_urb_comp }\n");
}
static int usb_net_raw_ip_init(void)
{
int i;
int err;
char name[32];
pr_debug("usb_net_raw_ip_init {\n");
/* create multiple raw-ip network devices */
for (i = 0; i < max_intfs; i++) {
/* open baseband usb */
g_i = i;
baseband_usb_net[i] = baseband_usb_open(i, usb_net_raw_ip_vid,
usb_net_raw_ip_pid, usb_net_raw_ip_intf[i]);
if (!baseband_usb_net[i]) {
pr_err("cannot open baseband usb net\n");
err = -1;
goto error_exit;
}
/* register network device */
usb_net_raw_ip_dev[i] = alloc_netdev(0,
BASEBAND_USB_NET_DEV_NAME,
ether_setup);
if (!usb_net_raw_ip_dev[i]) {
pr_err("alloc_netdev() failed\n");
err = -ENOMEM;
goto error_exit;
}
usb_net_raw_ip_dev[i]->netdev_ops = &usb_net_raw_ip_ops;
usb_net_raw_ip_dev[i]->watchdog_timeo = TX_TIMEOUT;
random_ether_addr(usb_net_raw_ip_dev[i]->dev_addr);
err = register_netdev(usb_net_raw_ip_dev[i]);
if (err < 0) {
pr_err("cannot register network device - %d\n", err);
goto error_exit;
}
pr_debug("registered baseband usb network device"
" - dev %p name %s\n", usb_net_raw_ip_dev[i],
BASEBAND_USB_NET_DEV_NAME);
/* start usb rx */
err = usb_net_raw_ip_setup_rx_urb(baseband_usb_net[i]);
if (err < 0) {
pr_err("setup reusable rx urb failed - err %d\n", err);
goto error_exit;
}
err = usb_net_raw_ip_rx_urb_submit(baseband_usb_net[i]);
if (err < 0) {
pr_err("submit rx failed - err %d\n", err);
goto error_exit;
}
/* start usb tx */
init_usb_anchor(&baseband_usb_net[i]->usb.tx_urb_deferred);
sprintf(name, "raw_ip_tx_wq-%d",
baseband_usb_net[i]->baseband_index);
baseband_usb_net[i]->usb.tx_workqueue
= create_singlethread_workqueue(name);
if (!baseband_usb_net[i]->usb.tx_workqueue) {
pr_err("cannot create workqueue\n");
goto error_exit;
}
INIT_WORK(&baseband_usb_net[i]->usb.tx_work,
usb_net_raw_ip_tx_urb_work);
}
pr_debug("usb_net_raw_ip_init }\n");
return 0;
error_exit:
/* destroy multiple raw-ip network devices */
for (i = 0; i < max_intfs; i++) {
/* unregister network device */
if (usb_net_raw_ip_dev[i]) {
unregister_netdev(usb_net_raw_ip_dev[i]);
free_netdev(usb_net_raw_ip_dev[i]);
usb_net_raw_ip_dev[i] = (struct net_device *) 0;
}
/* close baseband usb */
if (baseband_usb_net[i]) {
/* stop usb tx */
if (baseband_usb_net[i]->usb.tx_workqueue) {
destroy_workqueue(baseband_usb_net[i]
->usb.tx_workqueue);
baseband_usb_net[i]->usb.tx_workqueue
= (struct workqueue_struct *) 0;
}
if (baseband_usb_net[i]->usb.tx_urb) {
usb_kill_urb(baseband_usb_net[i]->usb.tx_urb);
baseband_usb_net[i]->usb.tx_urb
= (struct urb *) 0;
}
/* stop usb rx */
if (baseband_usb_net[i]->usb.rx_urb) {
usb_kill_urb(baseband_usb_net[i]->usb.rx_urb);
baseband_usb_net[i]->usb.rx_urb
= (struct urb *) 0;
}
usb_net_raw_ip_free_rx_urb(baseband_usb_net[i]);
/* close usb */
baseband_usb_close(baseband_usb_net[i]);
baseband_usb_net[i] = (struct baseband_usb *) 0;
}
}
return err;
}
static void usb_net_raw_ip_rx_urb_comp(struct urb *urb)
{
struct baseband_usb *usb = (struct baseband_usb *) urb->context;
int i = usb->baseband_index;
struct sk_buff *skb;
unsigned char *dst;
unsigned char ethernet_header[14] = {
/* Destination MAC */
0x00, 0x00,
0x00, 0x00,
0x00, 0x00,
/* Source MAC */
0x00, 0x00,
0x00, 0x00,
0x00, 0x00,
/* EtherType */
NET_IP_ETHERTYPE,
};
pr_debug("usb_net_raw_ip_rx_urb_comp { urb %p\n", urb);
/* check input */
if (!urb) {
pr_err("no urb\n");
return;
}
switch (urb->status) {
case 0:
break;
case -ENOENT:
/* fall through */
case -ESHUTDOWN:
/* fall through */
case -EPROTO:
pr_info("%s: rx urb %p - link shutdown %d\n",
__func__, urb, urb->status);
goto err_exit;
default:
pr_info("%s: rx urb %p - status %d\n",
__func__, urb, urb->status);
break;
}
/* put rx urb data in rx buffer */
if (urb->actual_length) {
pr_debug("usb_net_raw_ip_rx_urb_comp - "
"urb->actual_length %d\n", urb->actual_length);
/* allocate skb with space for
* - dummy ethernet header
* - rx IP packet from modem
*/
skb = netdev_alloc_skb(usb_net_raw_ip_dev[i],
NET_IP_ALIGN + 14 + urb->actual_length);
if (skb) {
/* generate a dummy ethernet header
* since modem sends IP packets without
* any ethernet headers
*/
memcpy(ethernet_header + 0,
usb_net_raw_ip_dev[i]->dev_addr, 6);
memcpy(ethernet_header + 6,
"0x01\0x02\0x03\0x04\0x05\0x06", 6);
/* fill skb with
* - dummy ethernet header
* - rx IP packet from modem
*/
skb_reserve(skb, NET_IP_ALIGN);
dst = skb_put(skb, 14);
memcpy(dst, ethernet_header, 14);
dst = skb_put(skb, urb->actual_length);
memcpy(dst, urb->transfer_buffer, urb->actual_length);
skb->protocol = eth_type_trans(skb,
usb_net_raw_ip_dev[i]);
/* pass skb to network stack */
if (netif_rx(skb) < 0) {
pr_err("usb_net_raw_ip_rx_urb_comp_work - "
"netif_rx(%p) failed\n", skb);
kfree_skb(skb);
usb->stats.rx_errors++;
} else {
usb->stats.rx_packets++;
usb->stats.rx_bytes +=
(14 + urb->actual_length);
}
} else {
pr_err("usb_net_raw_ip_rx_urb_comp_work - "
"netdev_alloc_skb() failed\n");
}
}
/* mark rx urb complete */
usb->usb.rx_urb = (struct urb *) 0;
/* submit next rx urb */
usb_net_raw_ip_rx_urb_submit(usb);
return;
err_exit:
/* mark rx urb complete */
usb->usb.rx_urb = (struct urb *) 0;
pr_debug("usb_net_raw_ip_rx_urb_comp }\n");
return;
}
static void usb_net_raw_ip_rx_urb_comp(struct urb *urb)
{
struct baseband_usb *usb;
int i = 0;
//+Sophia:0112
struct net_device *dev = (struct net_device *) usb_net_raw_ip_dev[i];
struct rmnet_private *p = netdev_priv(dev);
//-Sophia:0112
struct sk_buff *skb;
unsigned char *dst;
unsigned char ethernet_header[14] = {
/* Destination MAC */
0x00, 0x00,
0x00, 0x00,
0x00, 0x00,
/* Source MAC */
0x00, 0x00,
0x00, 0x00,
0x00, 0x00,
/* EtherType */
NET_IP_ETHERTYPE,
};
if (verbose) pr_info("usb_net_raw_ip_rx_urb_comp { urb %p\n", urb);
/* check input */
if (!urb) {
pr_err("no urb\n");
return;
}
usb = (struct baseband_usb *)urb->context;
i = usb->baseband_index;
/* 77969-8 patch */
switch (urb->status) {
case 0:
break;
case -ESHUTDOWN:
/* fall through */
pr_info("%s: rx urb %p - link shutdown %d\n",
__func__, urb, urb->status);
goto err_exit;
case -EPROTO:
pr_info("%s: rx urb %p - link shutdown %d EPROTO\n",
__func__, urb, urb->status);
usb_register_dump();
goto err_exit;
default:
pr_info("%s: rx urb %p - status %d\n",
__func__, urb, urb->status);
break;
}
/* 77969-8 patch */
/* put rx urb data in rx buffer */
if (urb->actual_length > 0) {
pr_debug("usb_net_raw_ip_rx_urb_comp - "
"urb->actual_length %d\n", urb->actual_length);
/* allocate skb with space for
* - dummy ethernet header
* - rx IP packet from modem
*/
skb = netdev_alloc_skb(usb_net_raw_ip_dev[i],
NET_IP_ALIGN + 14 + urb->actual_length);
if (skb) {
/* generate a dummy ethernet header
* since modem sends IP packets without
* any ethernet headers
*/
memcpy(ethernet_header + 0,
usb_net_raw_ip_dev[i]->dev_addr, 6);
memcpy(ethernet_header + 6,
"0x01\0x02\0x03\0x04\0x05\0x06", 6);
/* fill skb with
* - dummy ethernet header
* - rx IP packet from modem
*/
skb_reserve(skb, NET_IP_ALIGN);
dst = skb_put(skb, 14);
memcpy(dst, ethernet_header, 14);
dst = skb_put(skb, urb->actual_length);
memcpy(dst, urb->transfer_buffer, urb->actual_length);
//htc
if (host_dbg_flag & DBG_RAWIP_L1){
rawip_print_buffdata(urb->transfer_buffer, urb->actual_length,1);
}
//+Sophia:0112
p->stats.rx_packets++;
p->stats.rx_bytes += urb->actual_length;
//-Sophia:0112
skb->protocol = eth_type_trans(skb,
usb_net_raw_ip_dev[i]);
/* pass skb to network stack */
if (netif_rx(skb) < 0) {
pr_err("usb_net_raw_ip_rx_urb_comp_work - "
"netif_rx(%p) failed\n", skb);
kfree_skb(skb);
}
} else {
pr_err("usb_net_raw_ip_rx_urb_comp_work - "
"netdev_alloc_skb() failed\n");
}
}
/* mark rx urb complete */
usb->usb.rx_urb = (struct urb *) 0;
/* do not submit urb if interface is suspending */
if (urb->status == -ENOENT)
return;
/* submit next rx urb */
usb_net_raw_ip_rx_urb_submit(usb);
/* 77969-7 patch */
return;
err_exit:
/* mark rx urb complete */
usb->usb.rx_urb = (struct urb *) 0;
if (verbose) pr_info("usb_net_raw_ip_rx_urb_comp }\n");
return;
/* 77969-7 patch */
}
static int baseband_usb_driver_resume(struct usb_interface *intf)
{
int i, err, susp_count;
save_dbg(dbg_flag);/* HTC */
pr_debug("%s intf %p \n", __func__, intf);
//pr_info("%s: cnt with put async %d intf=%p &intf->dev=%p kobje=%s\n",
// __func__, atomic_read(&intf->dev.power.usage_count),intf,&intf->dev,kobject_name(&intf->dev.kobj));
for (i = 0; i < max_intfs; i++) {
//pr_debug("[%d]\n", i);
if (!baseband_usb_net[i])
continue;
if (baseband_usb_net[i]->usb.interface != intf) {
//pr_debug("[%d] %p != %p DebugOnly\n",i,
//baseband_usb_net[i]->usb.interface, intf);
continue;
}
/* decrement suspend count */
susp_count = --(baseband_usb_net[i]->susp_count);
if (susp_count > 0) {
pr_info("%s: susp_count %d > 0 (not resuming yet)\n",
__func__, susp_count);
continue;
}
if (susp_count < 0) {
pr_info("%s: susp_count %d < 0 (ILLEGAL VALUE)\n",
__func__, susp_count);
baseband_usb_net[i]->susp_count = 0;
continue;
}
pr_info("%s: susp_count = %d (resuming...)\n",
__func__, susp_count);
/* acquire semaphore */
if (down_interruptible(&baseband_usb_net[i]->sem)) {
pr_err("%s: cannot acquire semaphore\n", __func__);
continue;
}
/* start usb rx */
if (baseband_usb_net[i]->usb.rx_urb) {
pr_debug("rx_usb already exists\n");
up(&baseband_usb_net[i]->sem);
continue;
}
err = usb_net_raw_ip_rx_urb_submit(baseband_usb_net[i]);
if (err < 0) {
pr_err("submit rx failed - err %d\n", err);
up(&baseband_usb_net[i]->sem);
continue;
}
/* restart tx urb work (cancelled in suspend) */
if (!baseband_usb_net[i]->usb.tx_workqueue) {
pr_err("%s: !tx_workqueue\n", __func__);
up(&baseband_usb_net[i]->sem);
continue;
}
queue_work(baseband_usb_net[i]->usb.tx_workqueue,
&baseband_usb_net[i]->usb.tx_work);
/* release semaphore */
up(&baseband_usb_net[i]->sem);
}
restore_dbg(dbg_flag);/* HTC */
return 0;
}
