/* Grab the speed URB */
urb = self->speed_urb;
if (urb->status != 0) {
- WARNING("%s(), URB still in use!\n", __FUNCTION__);
+ IRDA_WARNING("%s(), URB still in use!\n", __FUNCTION__);
return;
}
/* Irq disabled -> GFP_ATOMIC */
if ((ret = usb_submit_urb(urb, GFP_ATOMIC))) {
- WARNING("%s(), failed Speed URB\n", __FUNCTION__);
+ IRDA_WARNING("%s(), failed Speed URB\n", __FUNCTION__);
}
}
IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
/* We should always have a context */
- ASSERT(self != NULL, return;);
+ IRDA_ASSERT(self != NULL, return;);
/* We should always be called for the speed URB */
- ASSERT(urb == self->speed_urb, return;);
+ IRDA_ASSERT(urb == self->speed_urb, return;);
/* Check for timeout and other USB nasties */
if (urb->status != 0) {
}
if (urb->status != 0) {
- WARNING("%s(), URB still in use!\n", __FUNCTION__);
+ IRDA_WARNING("%s(), URB still in use!\n", __FUNCTION__);
goto drop;
}
if (skb_headroom(skb) < USB_IRDA_HEADER) {
IRDA_DEBUG(0, "%s(), Insuficient skb headroom.\n", __FUNCTION__);
if (skb_cow(skb, USB_IRDA_HEADER)) {
- WARNING("%s(), failed skb_cow() !!!\n", __FUNCTION__);
+ IRDA_WARNING("%s(), failed skb_cow() !!!\n", __FUNCTION__);
goto drop;
}
}
/* Ask USB to send the packet - Irq disabled -> GFP_ATOMIC */
if ((res = usb_submit_urb(urb, GFP_ATOMIC))) {
- WARNING("%s(), failed Tx URB\n", __FUNCTION__);
+ IRDA_WARNING("%s(), failed Tx URB\n", __FUNCTION__);
self->stats.tx_errors++;
/* Let USB recover : We will catch that in the watchdog */
/*netif_start_queue(netdev);*/
IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
/* We should always have a context */
- ASSERT(self != NULL, return;);
+ IRDA_ASSERT(self != NULL, return;);
/* We should always be called for the speed URB */
- ASSERT(urb == self->tx_urb, return;);
+ IRDA_ASSERT(urb == self->tx_urb, return;);
/* Free up the skb */
dev_kfree_skb_any(skb);
int done = 0; /* If we have made any progress */
IRDA_DEBUG(0, "%s(), Network layer thinks we timed out!\n", __FUNCTION__);
- ASSERT(self != NULL, return;);
+ IRDA_ASSERT(self != NULL, return;);
/* Protect us from USB callbacks, net Tx and else. */
spin_lock_irqsave(&self->lock, flags);
/* self->present *MUST* be read under spinlock */
if (!self->present) {
- WARNING("%s(), device not present!\n", __FUNCTION__);
+ IRDA_WARNING("%s(), device not present!\n", __FUNCTION__);
netif_stop_queue(netdev);
spin_unlock_irqrestore(&self->lock, flags);
return;
IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
/* This should never happen */
- ASSERT(skb != NULL, return;);
- ASSERT(urb != NULL, return;);
+ IRDA_ASSERT(skb != NULL, return;);
+ IRDA_ASSERT(urb != NULL, return;);
/* Save ourselves in the skb */
cb = (struct irda_skb_cb *) skb->cb;
if (ret) {
/* If this ever happen, we are in deep s***.
* Basically, the Rx path will stop... */
- WARNING("%s(), Failed to submit Rx URB %d\n", __FUNCTION__, ret);
+ IRDA_WARNING("%s(), Failed to submit Rx URB %d\n",
+ __FUNCTION__, ret);
}
}
/* Find ourselves */
cb = (struct irda_skb_cb *) skb->cb;
- ASSERT(cb != NULL, return;);
+ IRDA_ASSERT(cb != NULL, return;);
self = (struct irda_usb_cb *) cb->context;
- ASSERT(self != NULL, return;);
+ IRDA_ASSERT(self != NULL, return;);
/* If the network is closed or the device gone, stop everything */
if ((!self->netopen) || (!self->present)) {
/* Check for empty frames */
if (urb->actual_length <= USB_IRDA_HEADER) {
- WARNING("%s(), empty frame!\n", __FUNCTION__);
+ IRDA_WARNING("%s(), empty frame!\n", __FUNCTION__);
goto done;
}
IRDA_DEBUG(1, "%s()\n", __FUNCTION__);
- ASSERT(netdev != NULL, return -1;);
+ IRDA_ASSERT(netdev != NULL, return -1;);
self = (struct irda_usb_cb *) netdev->priv;
- ASSERT(self != NULL, return -1;);
+ IRDA_ASSERT(self != NULL, return -1;);
/* Can only open the device if it's there */
if(!self->present) {
- WARNING("%s(), device not present!\n", __FUNCTION__);
+ IRDA_WARNING("%s(), device not present!\n", __FUNCTION__);
return -1;
}
*/
sprintf(hwname, "usb#%d", self->usbdev->devnum);
self->irlap = irlap_open(netdev, &self->qos, hwname);
- ASSERT(self->irlap != NULL, return -1;);
+ IRDA_ASSERT(self->irlap != NULL, return -1;);
/* Allow IrLAP to send data to us */
netif_start_queue(netdev);
if (!skb) {
/* If this ever happen, we are in deep s***.
* Basically, we can't start the Rx path... */
- WARNING("%s(), Failed to allocate Rx skb\n", __FUNCTION__);
+ IRDA_WARNING("%s(), Failed to allocate Rx skb\n",
+ __FUNCTION__);
return -1;
}
//skb_reserve(newskb, USB_IRDA_HEADER - 1);
IRDA_DEBUG(1, "%s()\n", __FUNCTION__);
- ASSERT(netdev != NULL, return -1;);
+ IRDA_ASSERT(netdev != NULL, return -1;);
self = (struct irda_usb_cb *) netdev->priv;
- ASSERT(self != NULL, return -1;);
+ IRDA_ASSERT(self != NULL, return -1;);
/* Clear this flag *before* unlinking the urbs and *before*
* stopping the network Tx queue - Jean II */
struct urb *urb = self->rx_urb[i];
struct sk_buff *skb = (struct sk_buff *) urb->context;
/* Cancel the receive command */
- usb_unlink_urb(urb);
+ usb_kill_urb(urb);
/* The skb is ours, free it */
if(skb) {
dev_kfree_skb(skb);
struct irda_usb_cb *self;
int ret = 0;
- ASSERT(dev != NULL, return -1;);
+ IRDA_ASSERT(dev != NULL, return -1;);
self = dev->priv;
- ASSERT(self != NULL, return -1;);
+ IRDA_ASSERT(self != NULL, return -1;);
IRDA_DEBUG(2, "%s(), %s, (cmd=0x%X)\n", __FUNCTION__, dev->name, cmd);
/* This is our interrupt endpoint */
self->bulk_int_ep = ep;
} else {
- ERROR("%s(), Unrecognised endpoint %02X.\n", __FUNCTION__, ep);
+ IRDA_ERROR("%s(), Unrecognised endpoint %02X.\n", __FUNCTION__, ep);
}
}
}
IRDA_DEBUG(0, "%s(), And our endpoints are : in=%02X, out=%02X (%d), int=%02X\n",
__FUNCTION__, self->bulk_in_ep, self->bulk_out_ep, self->bulk_out_mtu, self->bulk_int_ep);
/* Should be 8, 16, 32 or 64 bytes */
- ASSERT(self->bulk_out_mtu == 64, ;);
+ IRDA_ASSERT(self->bulk_out_mtu == 64, ;);
return((self->bulk_in_ep != 0) && (self->bulk_out_ep != 0));
}
IU_REQ_GET_CLASS_DESC,
USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
0, intf->altsetting->desc.bInterfaceNumber, desc,
- sizeof(*desc), msecs_to_jiffies(500));
+ sizeof(*desc), 500);
IRDA_DEBUG(1, "%s(), ret=%d\n", __FUNCTION__, ret);
if (ret < sizeof(*desc)) {
- WARNING("usb-irda: class_descriptor read %s (%d)\n",
- (ret<0) ? "failed" : "too short", ret);
+ IRDA_WARNING("usb-irda: class_descriptor read %s (%d)\n",
+ (ret<0) ? "failed" : "too short", ret);
}
else if (desc->bDescriptorType != USB_DT_IRDA) {
- WARNING("usb-irda: bad class_descriptor type\n");
+ IRDA_WARNING("usb-irda: bad class_descriptor type\n");
}
else {
#ifdef IU_DUMP_CLASS_DESC
* don't need to check if the dongle is really ours.
* Jean II */
- MESSAGE("IRDA-USB found at address %d, Vendor: %x, Product: %x\n",
- dev->devnum, le16_to_cpu(dev->descriptor.idVendor),
- le16_to_cpu(dev->descriptor.idProduct));
+ IRDA_MESSAGE("IRDA-USB found at address %d, Vendor: %x, Product: %x\n",
+ dev->devnum, le16_to_cpu(dev->descriptor.idVendor),
+ le16_to_cpu(dev->descriptor.idProduct));
net = alloc_irdadev(sizeof(*self));
if (!net)
goto err_out;
+ SET_MODULE_OWNER(net);
+ SET_NETDEV_DEV(net, &intf->dev);
self = net->priv;
self->netdev = net;
spin_lock_init(&self->lock);
- SET_MODULE_OWNER(net);
-
/* Create all of the needed urbs */
for (i = 0; i < IU_MAX_RX_URBS; i++) {
self->rx_urb[i] = usb_alloc_urb(0, GFP_KERNEL);
interface = intf->cur_altsetting;
if(!irda_usb_parse_endpoints(self, interface->endpoint,
interface->desc.bNumEndpoints)) {
- ERROR("%s(), Bogus endpoints...\n", __FUNCTION__);
+ IRDA_ERROR("%s(), Bogus endpoints...\n", __FUNCTION__);
ret = -EIO;
goto err_out_3;
}
if (ret)
goto err_out_4;
- MESSAGE("IrDA: Registered device %s\n", net->name);
+ IRDA_MESSAGE("IrDA: Registered device %s\n", net->name);
usb_set_intfdata(intf, self);
return 0;
netif_stop_queue(self->netdev);
/* Stop all the receive URBs */
for (i = 0; i < IU_MAX_RX_URBS; i++)
- usb_unlink_urb(self->rx_urb[i]);
+ usb_kill_urb(self->rx_urb[i]);
/* Cancel Tx and speed URB.
* Toggle flags to make sure it's synchronous. */
self->tx_urb->transfer_flags &= ~URB_ASYNC_UNLINK;
if (ret < 0)
return ret;
- MESSAGE("USB IrDA support registered\n");
+ IRDA_MESSAGE("USB IrDA support registered\n");
return 0;
}
module_init(usb_irda_init);