static void camera_disconnect(struct usb_device *dev, void *ptr)
{
struct camera_state *camera = (struct camera_state *) ptr;
int subminor = camera->subminor;
down (&state_table_mutex);
down (&camera->sem);
devfs_unregister(camera->devfs);
/* If camera's not opened, we can clean up right away.
* Else apps see a disconnect on next I/O; the release cleans.
*/
if (!camera->buf) {
minor_data [subminor] = NULL;
kfree (camera);
camera = NULL;
} else
camera->dev = NULL;
info ("USB Camera #%d disconnected", subminor);
usb_dec_dev_use (dev);
if (camera != NULL)
up (&camera->sem);
up (&state_table_mutex);
}
static void CDCEther_disconnect( struct usb_device *usb, void *ptr )
{
ether_dev_t *ether_dev = ptr;
// Sanity check!!!
if ( !ether_dev || !ether_dev->usb ) {
// We failed. We are insane!!!
warn("unregistering non-existant device");
return;
}
// Make sure we fail the sanity check if we try this again.
ether_dev->usb = NULL;
// It is possible that this function is called before
// the "close" function.
// This tells the close function we are already disconnected
ether_dev->flags |= CDC_ETHER_UNPLUG;
// We don't need the network device any more
unregister_netdev( ether_dev->net );
// For sanity checks
ether_dev->net = NULL;
// I ask again, does this do anything???
usb_dec_dev_use( usb );
// We are done with this interface
usb_driver_release_interface( &CDCEther_driver,
&(usb->config[ether_dev->configuration_num].interface[ether_dev->comm_interface]) );
// We are done with this interface too
usb_driver_release_interface( &CDCEther_driver,
&(usb->config[ether_dev->configuration_num].interface[ether_dev->data_interface]) );
// No more tied up kernel memory
kfree( ether_dev );
// This does no good, but it looks nice!
ether_dev = NULL;
}
static void *usb_rtusb_probe(struct usb_device *dev, UINT interface,
const struct usb_device_id *id_table)
{
PRTMP_ADAPTER pAd = (PRTMP_ADAPTER)NULL;
int i;
struct net_device *netdev;
int res = -ENOMEM;
DBGPRINT(RT_DEBUG_TRACE, "%s-->\n", __FUNCTION__);
for (i = 0; i < rtusb_usb_id_len; i++)
{
if (dev->descriptor.idVendor == rtusb_usb_id[i].idVendor &&
dev->descriptor.idProduct == rtusb_usb_id[i].idProduct)
{
printk("idVendor = 0x%x, idProduct = 0x%x \n",dev->descriptor.idVendor, dev->descriptor.idProduct);
break;
}
}
if (i == rtusb_usb_id_len) {
printk("Device Descriptor not matching\n");
return NULL;
}
netdev = alloc_etherdev(sizeof(PRTMP_ADAPTER));
if(!netdev)
{
printk("alloc_etherdev failed\n");
MOD_DEC_USE_COUNT;
usb_dec_dev_use(dev);
return NULL;
}
netdev->priv = (PVOID)vmalloc(sizeof(RTMP_ADAPTER));
pAd = netdev->priv;
if(pAd == NULL)
{
kfree(pAd->net_dev);
printk("vmalloc failed\n");
return NULL;
}
NdisZeroMemory(pAd, sizeof(RTMP_ADAPTER));
pAd->net_dev = netdev;
netif_stop_queue(netdev);
pAd->config = dev->config;
pAd->pUsb_Dev= dev;
SET_MODULE_OWNER(pAd->net_dev);
ether_setup(pAd->net_dev);
netdev->priv_flags = INT_MAIN;
netdev->open = usb_rtusb_open;
netdev->hard_start_xmit = usb_rtusb_sendpkt;
netdev->stop = usb_rtusb_close;
netdev->priv = pAd;
netdev->get_stats = rt73_get_ether_stats;
#if (WIRELESS_EXT >= 12)
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
netdev->get_wireless_stats = rt73_get_wireless_stats;
#endif
netdev->wireless_handlers = (struct iw_handler_def *) &rt73_iw_handler_def;
#endif
netdev->do_ioctl = rt73_ioctl;
pAd->net_dev->hard_header_len = 14;
pAd->net_dev->mtu = 1500;
pAd->net_dev->addr_len = 6;
pAd->net_dev->weight = 64;
OPSTATUS_CLEAR_FLAG(pAd, fOP_STATUS_MEDIA_STATE_CONNECTED);
{// find available
int i=0;
char slot_name[IFNAMSIZ];
struct net_device *device;
struct usb_interface *ifp= &dev->actconfig->interface[interface]; // get interface from system
struct usb_interface_descriptor *as;
struct usb_endpoint_descriptor *ep;
for (i = 0; i < 8; i++)
{
sprintf(slot_name, "rausb%d", i);
read_lock_bh(&dev_base_lock); // avoid multiple init
//Benson modify -->
for (device = dev_base; device != NULL; device = device->next)
//<-- Benson modify
{
if (strncmp(device->name, slot_name, 4) == 0)
{
break;
}
}
read_unlock_bh(&dev_base_lock);
if(device == NULL) break;
}
if(i == 8)
{
DBGPRINT(RT_DEBUG_ERROR, "No available slot name\n");
return NULL;
}
sprintf(pAd->net_dev->name, "rausb%d", i);
DBGPRINT(RT_DEBUG_ERROR, "usb device name %s\n",pAd->net_dev->name);
/* get Max Packet Size from usb_dev endpoint */
// ifp = dev->actconfig->interface + i;
as = ifp->altsetting + ifp->act_altsetting;
ep = as->endpoint;
pAd->BulkOutMaxPacketSize = (USHORT)ep[i].wMaxPacketSize;
DBGPRINT(RT_DEBUG_TRACE, "BulkOutMaxPacketSize %d\n", pAd->BulkOutMaxPacketSize);
}
res = register_netdev(pAd->net_dev);
if (res)
goto out;
RTMP_CLEAR_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST);
if (usb_rtusb_init_device(pAd->net_dev)!=NDIS_STATUS_SUCCESS)
goto out;
DBGPRINT(RT_DEBUG_TRACE, "%s<--\n", __FUNCTION__);
return pAd;
out:
printk("register_netdev failed err=%d\n",res);
return NULL;
}
