static int probe_rio(struct usb_interface *intf,
const struct usb_device_id *id)
{
struct usb_device *dev = interface_to_usbdev(intf);
struct rio_usb_data *rio = &rio_instance;
int retval = 0;
mutex_lock(&rio500_mutex);
if (rio->present) {
dev_info(&intf->dev, "Second USB Rio at address %d refused\n", dev->devnum);
retval = -EBUSY;
goto bail_out;
} else {
dev_info(&intf->dev, "USB Rio found at address %d\n", dev->devnum);
}
retval = usb_register_dev(intf, &usb_rio_class);
if (retval) {
dev_err(&dev->dev,
"Not able to get a minor for this device.\n");
retval = -ENOMEM;
goto bail_out;
}
rio->rio_dev = dev;
if (!(rio->obuf = kmalloc(OBUF_SIZE, GFP_KERNEL))) {
dev_err(&dev->dev,
"probe_rio: Not enough memory for the output buffer\n");
usb_deregister_dev(intf, &usb_rio_class);
retval = -ENOMEM;
goto bail_out;
}
dev_dbg(&intf->dev, "obuf address:%p\n", rio->obuf);
if (!(rio->ibuf = kmalloc(IBUF_SIZE, GFP_KERNEL))) {
dev_err(&dev->dev,
"probe_rio: Not enough memory for the input buffer\n");
usb_deregister_dev(intf, &usb_rio_class);
kfree(rio->obuf);
retval = -ENOMEM;
goto bail_out;
}
dev_dbg(&intf->dev, "ibuf address:%p\n", rio->ibuf);
usb_set_intfdata (intf, rio);
rio->present = 1;
bail_out:
mutex_unlock(&rio500_mutex);
return retval;
}
static void synccom_disconnect(struct usb_interface *interface)
{
struct synccom_port *port;
int minor = interface->minor;
port = usb_get_intfdata(interface);
usb_set_intfdata(interface, NULL);
/* give back our minor */
usb_deregister_dev(interface, &synccom_class);
/* prevent more I/O from starting */
mutex_lock(&port->io_mutex);
port->interface = NULL;
mutex_unlock(&port->io_mutex);
usb_kill_anchored_urbs(&port->submitted);
/* decrement our usage count */
kref_put(&port->kref, synccom_delete);
del_timer(&port->timer);
dev_info(&interface->dev, "USB synccom #%d now disconnected", minor);
}
static void usb_dio_disconnect(struct usb_interface *interface) {
usb_dio_dev *dev;
int minor = interface->minor;
FUNC_HI();
/* give back our minor */
usb_deregister_dev(interface, &usb_dio_class);
dev = usb_get_intfdata(interface);
if (!dev) {
FUNC_ERR();
return;
}
usb_set_intfdata(interface, NULL);
dev->running = 0;
if (dev->bulk_in_urb) {
DPRINTK(KERN_ALERT "*** killing urb @ %p\n",dev->bulk_in_urb);
usb_kill_urb(dev->bulk_in_urb);
}
/* decrement our usage count - this does kfree(dev) */
kref_put(&(dev->kref), diodev_delete);
printk(KERN_ALERT "%s: Disconnected #%d\n", usb_dio_driver.name, minor);
FUNC_BYE();
}
static void chaoskey_disconnect(struct usb_interface *interface)
{
struct chaoskey *dev;
usb_dbg(interface, "disconnect");
dev = usb_get_intfdata(interface);
if (!dev) {
usb_dbg(interface, "disconnect failed - no dev");
return;
}
if (dev->hwrng_registered)
hwrng_unregister(&dev->hwrng);
usb_deregister_dev(interface, &chaoskey_class);
usb_set_intfdata(interface, NULL);
mutex_lock(&dev->lock);
dev->present = 0;
usb_poison_urb(dev->urb);
if (!dev->open) {
mutex_unlock(&dev->lock);
chaoskey_free(dev);
} else
mutex_unlock(&dev->lock);
usb_dbg(interface, "disconnect done");
}
static void bladerf_disconnect(struct usb_interface *interface)
{
bladerf_device_t *dev;
if (interface->cur_altsetting->desc.bInterfaceNumber != 0)
return;
dev = usb_get_intfdata(interface);
dev->disconnecting = 1;
dev->tx_en = 0;
dev->rx_en = 0;
usb_kill_anchored_urbs(&dev->data_out_anchor);
usb_kill_anchored_urbs(&dev->data_in_anchor);
bladerf_stop(dev);
usb_deregister_dev(interface, &bladerf_class);
usb_set_intfdata(interface, NULL);
usb_put_dev(dev->udev);
dev_info(&interface->dev, "Nuand bladeRF device has been disconnected\n");
kfree(dev);
}
static void usblp_disconnect(struct usb_interface *intf)
{
struct usblp *usblp = usb_get_intfdata (intf);
usb_deregister_dev(intf, &usblp_class);
if (!usblp || !usblp->dev) {
err("bogus disconnect");
BUG ();
}
device_remove_file(&intf->dev, &dev_attr_ieee1284_id);
down (&usblp_sem);
down (&usblp->sem);
usblp->present = 0;
usb_set_intfdata (intf, NULL);
usblp_unlink_urbs(usblp);
usb_buffer_free (usblp->dev, USBLP_BUF_SIZE,
usblp->writebuf, usblp->writeurb->transfer_dma);
usb_buffer_free (usblp->dev, USBLP_BUF_SIZE,
usblp->readbuf, usblp->readurb->transfer_dma);
up (&usblp->sem);
if (!usblp->used)
usblp_cleanup (usblp);
up (&usblp_sem);
}
static void disconnect_aw(struct usb_interface *intf)
{
struct aw_usb_data *aw = usb_get_intfdata(intf);
usb_set_intfdata(intf, NULL);
if (aw) {
usb_deregister_dev(intf, &usb_aw_class);
mutex_lock(&(aw->lock));
if (aw->isopen) {
aw->isopen = 0;
/* Better let it finish,
* the release will do whats needed
*/
aw->aw_dev = NULL;
mutex_unlock(&(aw->lock));
return;
}
kfree(aw->ibuf);
kfree(aw->obuf);
dev_info(&intf->dev, "USB aw disconnected.\n");
aw->present = 0;
mutex_unlock(&(aw->lock));
}
}
static void usbrh_disconnect(struct usb_interface *interface)
{
struct usbrh *dev;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39)
while(!mutex_lock_interruptible(&usbrh_ioctl_mutex)) {
schedule_timeout_interruptible(msecs_to_jiffies(100));
}
#else
lock_kernel();
#endif
dev = usb_get_intfdata(interface);
usb_set_intfdata(interface, NULL);
usb_deregister_dev(interface, &usbrh_class);
mutex_lock(&dev->io_mutex);
dev->interface = NULL;
mutex_unlock(&dev->io_mutex);
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39)
mutex_unlock(&usbrh_ioctl_mutex);
#else
unlock_kernel();
#endif
kref_put(&dev->kref, usbrh_delete);
info("USBRH disconnected");
}
static void dissociate_dev(struct rts51x_chip *chip)
{
struct rts51x_usb *rts51x = chip->usb;
RTS51X_DEBUGP("-- %s\n", __func__);
if (rts51x->cr)
usb_buffer_free(rts51x->pusb_dev, sizeof(*rts51x->cr),
rts51x->cr, rts51x->cr_dma);
if (rts51x->iobuf)
usb_buffer_free(rts51x->pusb_dev, RTS51X_IOBUF_SIZE,
rts51x->iobuf, rts51x->iobuf_dma);
usb_set_intfdata(rts51x->pusb_intf, NULL);
#ifdef SUPPORT_FILE_OP
usb_deregister_dev(rts51x->pusb_intf, &rts51x_class);
#endif
kfree(rts51x);
chip->usb = NULL;
}
/**
* fx2_disconnect - Called when the device is disconnected
*
* @intf: USB interface
*/
static void fx2_disconnect(struct usb_interface *intf)
{
struct osr_usb_fx2_dev *dev_priv = usb_get_intfdata(intf);
printk("fx2_disconnect /dev/osr_usb%d\n",
dev_priv->minor - FX2_MINOR_BASE);
osr_usb_attrib_cleanup(&intf->dev);
usb_set_intfdata(intf, NULL);
usb_deregister_dev(intf, &osr_usb_fx2_class);
if (dev_priv->int_urb)
usb_free_urb(dev_priv->int_urb);
if (dev_priv->int_buffer)
kfree(dev_priv->int_buffer);
if (dev_priv->bulk_buffer)
kfree(dev_priv->bulk_buffer);
kfree(dev_priv);
}
void
vote_disconnect(struct usb_interface *interface)
{
struct usb_vote *vote_dev;
int minor = interface->minor;
printk(KERN_DEBUG "vote: process %i (%s) vote_disconnect\n",
current->pid, current->comm);
// Acquire the big kernel lock to prevent open() from racing disconnect()
lock_kernel();
// Get our data structure that was saved in the device interface in probe()
// and then we can set interface to NULL.
vote_dev = usb_get_intfdata(interface);
usb_set_intfdata(interface, NULL);
// Remove SYSFS entries.
device_remove_file(&interface->dev, &dev_attr_voting);
// Unregister the device to give back the minor number to the usb core
usb_deregister_dev(interface, &vote_class);
// Release the kernel lock
unlock_kernel();
// Decrement our reference counter
kref_put(&vote_dev->refcount, vote_delete);
// output disconnect message
printk(KERN_NOTICE "USB vote #%d now disconnected\n", minor);
} // vote_disconnect
static void ld_usb_disconnect(struct usb_interface *intf)
{
struct ld_usb *dev;
int minor;
dev = usb_get_intfdata(intf);
usb_set_intfdata(intf, NULL);
minor = intf->minor;
usb_deregister_dev(intf, &ld_usb_class);
mutex_lock(&dev->mutex);
if (!dev->open_count) {
mutex_unlock(&dev->mutex);
ld_usb_delete(dev);
} else {
dev->intf = NULL;
wake_up_interruptible_all(&dev->read_wait);
wake_up_interruptible_all(&dev->write_wait);
mutex_unlock(&dev->mutex);
}
dev_info(&intf->dev, "LD USB Device #%d now disconnected\n",
(minor - USB_LD_MINOR_BASE));
}
static int avrBridge_probe(struct usb_interface *interface, const struct usb_device_id *id)
{
struct usb_device *udev = interface_to_usbdev(interface);
struct avrBridge *dev = NULL;
struct usb_host_interface *iface_desc;
struct usb_endpoint_descriptor *endpoint;
size_t buffer_size;
int i;
int retval = -ENOMEM;
dev = kzalloc(sizeof(struct avrBridge), GFP_KERNEL);
if (dev == NULL) {
dev_err(&interface->dev, "Out of memory\n");
goto error_mem;
}
kref_init(&dev->kref);
sema_init(&dev->limit_sem, 8);
mutex_init(&dev->io_mutex);
spin_lock_init(&dev->err_lock);
init_usb_anchor(&dev->submitted);
dev->udev = usb_get_dev(udev);
dev->interface = interface;
dev->bulk_in_buffer = kmalloc(le16_to_cpu(512), GFP_KERNEL);
usb_set_intfdata (interface, dev);
retval = usb_register_dev(interface,&avrBridge_class);
if (retval) {
/* something prevented us from registering this device */
err("Unble to allocate minor number.");
usb_set_intfdata(interface, NULL);
return retval;
}
avrBridge_dir = proc_mkdir("avrBridge",NULL);
port_dir = proc_mkdir("ports",avrBridge_dir);
pin_dir = proc_mkdir("pins",avrBridge_dir);
/*
* Create an entry in /proc named "hello_world" that calls
* hello_read_proc() when the file is read.
*/
if (create_proc_read_entry("portB", 0, port_dir, avrBridge_read_proc,
NULL) == 0) {
printk(KERN_ERR
"Unable to register \"avrBridge\" proc file\n");
return -ENOMEM;
}
dev_info(&interface->dev, "avrBridge device now attached\n");
return 0;
error:
usb_deregister_dev(interface,&avrBridge_class);
usb_set_intfdata (interface, NULL);
usb_put_dev(dev->udev);
kfree(dev);
error_mem:
return retval;
}
/**
* ld_usb_disconnect
*
* Called by the usb core when the device is removed from the system.
*/
static void ld_usb_disconnect(struct usb_interface *intf)
{
struct ld_usb *dev;
int minor;
dev = usb_get_intfdata(intf);
usb_set_intfdata(intf, NULL);
minor = intf->minor;
/* give back our minor */
usb_deregister_dev(intf, &ld_usb_class);
mutex_lock(&dev->mutex);
/* if the device is not opened, then we clean up right now */
if (!dev->open_count) {
mutex_unlock(&dev->mutex);
ld_usb_delete(dev);
} else {
dev->intf = NULL;
/* wake up pollers */
wake_up_interruptible_all(&dev->read_wait);
wake_up_interruptible_all(&dev->write_wait);
mutex_unlock(&dev->mutex);
}
dev_info(&intf->dev, "LD USB Device #%d now disconnected\n",
(minor - USB_LD_MINOR_BASE));
}
static void dabusb_disconnect (struct usb_interface *intf)
{
wait_queue_t __wait;
pdabusb_t s = usb_get_intfdata (intf);
dbg("dabusb_disconnect");
init_waitqueue_entry(&__wait, current);
usb_set_intfdata (intf, NULL);
if (s) {
usb_deregister_dev (intf, &dabusb_class);
s->remove_pending = 1;
wake_up (&s->wait);
add_wait_queue(&s->remove_ok, &__wait);
set_current_state(TASK_UNINTERRUPTIBLE);
if (s->state == _started)
schedule();
current->state = TASK_RUNNING;
remove_wait_queue(&s->remove_ok, &__wait);
s->usbdev = NULL;
s->overruns = 0;
}
}
/**
* usb_tranzport_disconnect
*
* Called by the usb core when the device is removed from the system.
*/
static void usb_tranzport_disconnect(struct usb_interface *intf)
{
struct usb_tranzport *dev;
int minor;
mutex_lock(&disconnect_mutex);
dev = usb_get_intfdata(intf);
usb_set_intfdata(intf, NULL);
down(&dev->sem);
minor = intf->minor;
/* give back our minor */
usb_deregister_dev(intf, &usb_tranzport_class);
/* if the device is not opened, then we clean up right now */
if (!dev->open_count) {
up(&dev->sem);
usb_tranzport_delete(dev);
} else {
dev->intf = NULL;
up(&dev->sem);
}
mutex_unlock(&disconnect_mutex);
dev_info(&intf->dev, "Tranzport Surface #%d now disconnected\n",
(minor - USB_TRANZPORT_MINOR_BASE));
}
void lighty_disconnect(struct usb_interface *interface)
{
struct usb_lighty *dev;
int minor = interface->minor;
//acquire the big kernel lock to prevent open() from racing disconnect()
lock_kernel();
//get our data structure that was saved in the device interface in probe()
dev = usb_get_intfdata(interface);
//now set it to NULL
usb_set_intfdata(interface, NULL);
//unregister the device to give back the minor number to the usb core
usb_deregister_dev(interface, &lighty_class);
//release the kernel lock
unlock_kernel();
//decrement our reference counter
kref_put(&dev->refcount, lighty_delete);
//output disconnect message
printk(KERN_NOTICE "USB lighty #%d now disconnected\n", minor);
}
static void wdm_disconnect(struct usb_interface *intf)
{
struct wdm_device *desc;
unsigned long flags;
usb_deregister_dev(intf, &wdm_class);
mutex_lock(&wdm_mutex);
desc = usb_get_intfdata(intf);
/* the spinlock makes sure no new urbs are generated in the callbacks */
spin_lock_irqsave(&desc->iuspin, flags);
set_bit(WDM_DISCONNECTING, &desc->flags);
set_bit(WDM_READ, &desc->flags);
/* to terminate pending flushes */
clear_bit(WDM_IN_USE, &desc->flags);
spin_unlock_irqrestore(&desc->iuspin, flags);
mutex_lock(&desc->lock);
kill_urbs(desc);
cancel_work_sync(&desc->rxwork);
mutex_unlock(&desc->lock);
wake_up_all(&desc->wait);
if (!desc->count)
cleanup(desc);
mutex_unlock(&wdm_mutex);
}
static void disconnect_rio(struct usb_interface *intf)
{
struct rio_usb_data *rio = usb_get_intfdata (intf);
usb_set_intfdata (intf, NULL);
mutex_lock(&rio500_mutex);
if (rio) {
usb_deregister_dev(intf, &usb_rio_class);
mutex_lock(&(rio->lock));
if (rio->isopen) {
rio->isopen = 0;
/* better let it finish - the release will do whats needed */
rio->rio_dev = NULL;
mutex_unlock(&(rio->lock));
mutex_unlock(&rio500_mutex);
return;
}
kfree(rio->ibuf);
kfree(rio->obuf);
dev_info(&intf->dev, "USB Rio disconnected.\n");
rio->present = 0;
mutex_unlock(&(rio->lock));
}
mutex_unlock(&rio500_mutex);
}
/**
* adu_disconnect
*
* Called by the usb core when the device is removed from the system.
*/
static void adu_disconnect(struct usb_interface *interface)
{
struct adu_device *dev;
int minor;
dbg(2," %s : enter", __func__);
dev = usb_get_intfdata(interface);
mutex_lock(&dev->mtx); /* not interruptible */
dev->udev = NULL; /* poison */
minor = dev->minor;
usb_deregister_dev(interface, &adu_class);
mutex_unlock(&dev->mtx);
mutex_lock(&adutux_mutex);
usb_set_intfdata(interface, NULL);
/* if the device is not opened, then we clean up right now */
dbg(2," %s : open count %d", __func__, dev->open_count);
if (!dev->open_count)
adu_delete(dev);
mutex_unlock(&adutux_mutex);
dev_info(&interface->dev, "ADU device adutux%d now disconnected\n",
(minor - ADU_MINOR_BASE));
dbg(2," %s : leave", __func__);
}
static void as102_usb_disconnect(struct usb_interface *intf)
{
struct as102_dev_t *as102_dev;
ENTER();
/* extract as102_dev_t from usb_device private data */
as102_dev = usb_get_intfdata(intf);
/* unregister dvb layer */
as102_dvb_unregister(as102_dev);
/* free usb buffers */
as102_free_usb_stream_buffer(as102_dev);
usb_set_intfdata(intf, NULL);
/* usb unregister device */
usb_deregister_dev(intf, &as102_usb_class_driver);
/* decrement usage counter */
kref_put(&as102_dev->kref, as102_usb_release);
printk(KERN_INFO "%s: device has been disconnected\n", DRIVER_NAME);
LEAVE();
}
/**
* ld_usb_disconnect
*
* Called by the usb core when the device is removed from the system.
*/
static void ld_usb_disconnect(struct usb_interface *intf)
{
struct ld_usb *dev;
int minor;
down(&disconnect_sem);
dev = usb_get_intfdata(intf);
usb_set_intfdata(intf, NULL);
down(&dev->sem);
minor = intf->minor;
/* give back our minor */
usb_deregister_dev(intf, &ld_usb_class);
/* if the device is not opened, then we clean up right now */
if (!dev->open_count) {
up(&dev->sem);
ld_usb_delete(dev);
} else {
dev->intf = NULL;
up(&dev->sem);
}
up(&disconnect_sem);
dev_info(&intf->dev, "LD USB Device #%d now disconnected\n",
(minor - USB_LD_MINOR_BASE));
}
static void usbbcm_disconnect (struct usb_interface *intf)
{
PS_INTERFACE_ADAPTER psIntfAdapter = NULL;
PMINI_ADAPTER psAdapter = NULL;
struct usb_device *udev = NULL;
PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Usb disconnected");
if(intf == NULL)
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "intf pointer is NULL");
return;
}
psIntfAdapter = usb_get_intfdata(intf);
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "psIntfAdapter 0x%x",(unsigned int)psIntfAdapter);
if(psIntfAdapter == NULL)
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "InterfaceAdapter pointer is NULL");
return;
}
psAdapter = psIntfAdapter->psAdapter;
if(psAdapter->bDoSuspend)
intf->needs_remote_wakeup = 0;
psAdapter->device_removed = TRUE ;
usb_set_intfdata(intf, NULL);
InterfaceAdapterFree(psIntfAdapter);
udev = interface_to_usbdev (intf);
usb_put_dev(udev);
usb_deregister_dev (intf, &usbbcm_class);
}
static void yurex_disconnect(struct usb_interface *interface)
{
struct usb_yurex *dev;
int minor = interface->minor;
dev = usb_get_intfdata(interface);
usb_set_intfdata(interface, NULL);
/* give back our minor */
usb_deregister_dev(interface, &yurex_class);
/* prevent more I/O from starting */
mutex_lock(&dev->io_mutex);
dev->interface = NULL;
mutex_unlock(&dev->io_mutex);
/* wakeup waiters */
kill_fasync(&dev->async_queue, SIGIO, POLL_IN);
wake_up_interruptible(&dev->waitq);
/* decrement our usage count */
kref_put(&dev->kref, yurex_delete);
dev_info(&interface->dev, "USB YUREX #%d now disconnected\n", minor);
}
static void usblp_disconnect(struct usb_interface *intf)
{
struct usblp *usblp = usb_get_intfdata(intf);
usb_deregister_dev(intf, &usblp_class);
if (!usblp || !usblp->dev) {
dev_err(&intf->dev, "bogus disconnect\n");
BUG();
}
device_remove_file(&intf->dev, &dev_attr_ieee1284_id);
mutex_lock(&usblp_mutex);
mutex_lock(&usblp->mut);
usblp->present = 0;
if(pan_count > 0) // tmp fix
--pan_count;
wake_up(&usblp->wwait);
wake_up(&usblp->rwait);
usb_set_intfdata(intf, NULL);
usblp_unlink_urbs(usblp);
mutex_unlock(&usblp->mut);
if (!usblp->used)
usblp_cleanup(usblp);
mutex_unlock(&usblp_mutex);
}
/**
* usb_alphatrack_disconnect
*
* Called by the usb core when the device is removed from the system.
*/
static void usb_alphatrack_disconnect(struct usb_interface *intf)
{
struct usb_alphatrack *dev;
int minor;
mutex_lock(&disconnect_mutex);
dev = usb_get_intfdata(intf);
usb_set_intfdata(intf, NULL);
down(&dev->sem);
minor = intf->minor;
/* give back our minor */
usb_deregister_dev(intf, &usb_alphatrack_class);
/* if the device is not opened, then we clean up right now */
if (!dev->open_count) {
up(&dev->sem);
usb_alphatrack_delete(dev);
} else {
dev->intf = NULL;
up(&dev->sem);
}
atomic_set(&dev->writes_pending, 0);
mutex_unlock(&disconnect_mutex);
dev_info(&intf->dev, "Alphatrack Surface #%d now disconnected\n",
(minor - USB_ALPHATRACK_MINOR_BASE));
}
/*
* called by the usb core when the device is removed from the system
*/
static void cpcusb_disconnect(struct usb_interface *interface)
{
CPC_USB_T *card = NULL;
int minor, j;
/* prevent races with open() */
down(&disconnect_sem);
card = usb_get_intfdata(interface);
usb_set_intfdata(interface, NULL);
down(&card->sem);
/* prevent device read, write and ioctl */
card->present = 0;
minor = card->minor;
/* free all urbs and their buffers */
for (j = 0; j < CPC_USB_URB_CNT; j++) {
/* terminate an ongoing write */
if (atomic_read(&card->wrUrbs[j].busy)) {
usb_kill_urb(card->wrUrbs[j].urb);
wait_for_completion(&card->wrUrbs[j].finished);
}
usb_buffer_free(card->udev, card->wrUrbs[j].size,
card->wrUrbs[j].buffer,
card->wrUrbs[j].urb->transfer_dma);
usb_free_urb(card->wrUrbs[j].urb);
}
info("%d write URBs freed", CPC_USB_URB_CNT);
/* free all urbs and their buffers */
for (j = 0; j < CPC_USB_URB_CNT; j++) {
usb_buffer_free(card->udev, card->urbs[j].size,
card->urbs[j].buffer,
card->urbs[j].urb->transfer_dma);
usb_free_urb(card->urbs[j].urb);
}
info("%d read URBs freed", CPC_USB_URB_CNT);
usb_free_urb(card->intr_in_urb);
/* give back our minor */
usb_deregister_dev(interface, &cpcusb_class);
up(&card->sem);
/* if the device is opened, cpcusb_release will clean this up */
if (!card->open)
cpcusb_delete(card);
else
wake_up_interruptible(card->chan->CPCWait_q);
up(&disconnect_sem);
CPCUsbCnt--;
info("USB-%d now disconnected", minor);
}
static int probe_aw(struct usb_interface *intf,
const struct usb_device_id *id)
{
struct usb_device *dev = interface_to_usbdev(intf);
struct aw_usb_data *aw = &aw_instance;
int retval;
dev_info(&intf->dev, "USB aw found at address %d\n", dev->devnum);
retval = usb_register_dev(intf, &usb_aw_class);
if (retval) {
dev_err(&aw->aw_dev->dev,
"Not able to get a minor for this device.");
return -ENOMEM;
}
aw->aw_dev = dev;
aw->obuf = kmalloc(OBUF_SIZE, GFP_KERNEL);
if (!(aw->obuf)) {
dev_err(&aw->aw_dev->dev,
"probe_aw: Not enough memory for the output buffer");
usb_deregister_dev(intf, &usb_aw_class);
return -ENOMEM;
}
dbg("probe_aw: obuf address:%p", aw->obuf);
aw->ibuf = kmalloc(IBUF_SIZE, GFP_KERNEL);
if (!(aw->ibuf)) {
dev_err(&aw->aw_dev->dev,
"probe_aw: Not enough memory for the input buffer");
usb_deregister_dev(intf, &usb_aw_class);
kfree(aw->obuf);
return -ENOMEM;
}
dbg("probe_aw: ibuf address:%p", aw->ibuf);
mutex_init(&(aw->lock));
usb_set_intfdata(intf, aw);
aw->present = 1;
return 0;
}
//called when unplugging a USB device
static void
my_usb_disconnect(struct usb_interface *interface)
{
struct my_usb *sd = usb_get_intfdata(interface);
printk(KERN_INFO "usb device is disconnected");
usb_deregister_dev(interface, &sd->udc);
usb_put_dev(sd->udev);
kfree(sd);
}
static void simpleusb_disconnect(struct usb_interface *interface)
{
struct simpleusb_t *simpleusb_device;
printk(KERN_INFO "simpleusb: %s\n", __func__);
simpleusb_device = usb_get_intfdata(interface);
usb_set_intfdata(interface, NULL);
usb_deregister_dev(interface, &simpleusb_class);
//simpleusb_device->interface = NULL;
}
