/*-------------------------------------------------------------------*/
/* Forwards */
-static void auerswald_ctrlread_complete (struct urb * urb, struct pt_regs *regs);
+static void auerswald_ctrlread_complete (struct urb * urb);
static void auerswald_removeservice (pauerswald_t cp, pauerscon_t scp);
static struct usb_driver auerswald_driver;
/* -------------------------- */
/* completion function for chained urbs */
-static void auerchain_complete (struct urb * urb, struct pt_regs *regs)
+static void auerchain_complete (struct urb * urb)
{
unsigned long flags;
int result;
NOTE: this function may lead to more urbs submitted into the chain.
(no chain lock at calling complete()!)
acp->active != NULL is protecting us against recursion.*/
- urb->complete (urb, regs);
+ urb->complete (urb);
/* detach element from chain data structure */
spin_lock_irqsave (&acp->lock, flags);
urb->status = result;
dbg("auerchain_complete: usb_submit_urb with error code %d", result);
/* and do error handling via *this* completion function (recursive) */
- auerchain_complete( urb, NULL);
+ auerchain_complete( urb);
}
} else {
/* simple return without submitting a new urb.
urb->status = result;
dbg("auerchain_submit_urb: usb_submit_urb with error code %d", result);
/* and do error handling via completion function */
- auerchain_complete( urb, NULL);
+ auerchain_complete( urb);
}
}
spin_unlock_irqrestore (&acp->lock, flags);
dbg ("unlink waiting urb");
urb->status = -ENOENT;
- urb->complete (urb, NULL);
+ urb->complete (urb);
return 0;
}
}
spin_unlock_irqrestore (&acp->lock, flags);
dbg ("unlink waiting urb");
urbp->status = -ENOENT;
- urbp->complete (urbp, NULL);
+ urbp->complete (urbp);
spin_lock_irqsave (&acp->lock, flags);
}
spin_unlock_irqrestore (&acp->lock, flags);
/* fill the list of free elements */
for (;numElements; numElements--) {
- acep = (pauerchainelement_t) kmalloc (sizeof (auerchainelement_t), GFP_KERNEL);
+ acep = kzalloc(sizeof(auerchainelement_t), GFP_KERNEL);
if (!acep)
goto ac_fail;
- memset (acep, 0, sizeof (auerchainelement_t));
INIT_LIST_HEAD (&acep->list);
list_add_tail (&acep->list, &acp->free_list);
}
/* completion handler for synchronous chained URBs */
-static void auerchain_blocking_completion (struct urb *urb, struct pt_regs *regs)
+static void auerchain_blocking_completion (struct urb *urb)
{
pauerchain_chs_t pchs = (pauerchain_chs_t)urb->context;
pchs->done = 1;
/* fill the list of free elements */
for (;numElements; numElements--) {
- bep = (pauerbuf_t) kmalloc (sizeof (auerbuf_t), GFP_KERNEL);
+ bep = kzalloc(sizeof(auerbuf_t), GFP_KERNEL);
if (!bep)
goto bl_fail;
- memset (bep, 0, sizeof (auerbuf_t));
bep->list = bcp;
INIT_LIST_HEAD (&bep->buff_list);
bep->bufp = kmalloc (bufsize, GFP_KERNEL);
0 Initial, OK
-EINPROGRESS during submission until end
-ENOENT if urb is unlinked
--ETIMEDOUT Transfer timed out, NAK
+-ETIME Device did not respond
-ENOMEM Memory Overflow
-ENODEV Specified USB-device or bus doesn't exist
-ENXIO URB already queued
{
switch (status) {
case 0:
- case -ETIMEDOUT:
+ case -ETIME:
case -EOVERFLOW:
case -EAGAIN:
case -EPIPE:
}
/* Completion of asynchronous write block */
-static void auerchar_ctrlwrite_complete (struct urb * urb, struct pt_regs *regs)
+static void auerchar_ctrlwrite_complete (struct urb * urb)
{
pauerbuf_t bp = (pauerbuf_t) urb->context;
pauerswald_t cp = ((pauerswald_t)((char *)(bp->list)-(unsigned long)(&((pauerswald_t)0)->bufctl)));
}
/* Completion handler for dummy retry packet */
-static void auerswald_ctrlread_wretcomplete (struct urb * urb, struct pt_regs *regs)
+static void auerswald_ctrlread_wretcomplete (struct urb * urb)
{
pauerbuf_t bp = (pauerbuf_t) urb->context;
pauerswald_t cp;
if (ret) {
dbg ("auerswald_ctrlread_complete: nonzero result of auerchain_submit_urb_list %d", ret);
bp->urbp->status = ret;
- auerswald_ctrlread_complete (bp->urbp, NULL);
+ auerswald_ctrlread_complete (bp->urbp);
}
}
/* completion handler for receiving of control messages */
-static void auerswald_ctrlread_complete (struct urb * urb, struct pt_regs *regs)
+static void auerswald_ctrlread_complete (struct urb * urb)
{
unsigned int serviceid;
pauerswald_t cp;
if (ret) {
dbg ("auerswald_ctrlread_complete: nonzero result of auerchain_submit_urb_list %d", ret);
bp->urbp->status = ret;
- auerswald_ctrlread_wretcomplete (bp->urbp, regs);
+ auerswald_ctrlread_wretcomplete (bp->urbp);
}
return;
}
messages from the USB device.
*/
/* int completion handler. */
-static void auerswald_int_complete (struct urb * urb, struct pt_regs *regs)
+static void auerswald_int_complete (struct urb * urb)
{
unsigned long flags;
unsigned int channelid;
if (ret) {
dbg ("auerswald_int_complete: nonzero result of auerchain_submit_urb %d", ret);
bp->urbp->status = ret;
- auerswald_ctrlread_complete( bp->urbp, NULL);
+ auerswald_ctrlread_complete( bp->urbp);
/* here applies the same problem as above: device locking! */
}
exit:
/*----------------------------------------------------------------------*/
/* File operation structure */
-static struct file_operations auerswald_fops =
+static const struct file_operations auerswald_fops =
{
.owner = THIS_MODULE,
.llseek = no_llseek,