More __FUNCTION__ cleanups for IrDA

diff --git a/drivers/net/irda/actisys.c b/drivers/net/irda/actisys.c
index e2f325b73a41928d983e6ec15cdfcefb63d1cc72..ecabcf629f3d4deb2491587e39d3872f9ca75f21 100644 (file)
--- a/drivers/net/irda/actisys.c
+++ b/drivers/net/irda/actisys.c
@@ -165,7 +165,7 @@ static int actisys_change_speed(struct irda_task *task)
        int ret = 0;
        int i = 0;
 
-        IRDA_DEBUG(4, __FUNCTION__ "(), speed=%d (was %d)\n", speed, 
+        IRDA_DEBUG(4, "%s(), speed=%d (was %d)\n", __FUNCTION__, speed, 
                   self->speed);
 
        /* Go to a known state by reseting the dongle */

diff --git a/drivers/net/irda/irda-usb.c b/drivers/net/irda/irda-usb.c
index 3aeabdbdf0740a9407b92ffbb79a8136893e9746..2af88118b309500f3a63519f8f0a65dfea3c8fe6 100644 (file)
--- a/drivers/net/irda/irda-usb.c
+++ b/drivers/net/irda/irda-usb.c
@@ -156,12 +156,12 @@ static void irda_usb_build_header(struct irda_usb_cb *self,
                    (!force) && (self->speed != -1)) {
                        /* No speed and xbofs change here
                         * (we'll do it later in the write callback) */
-                       IRDA_DEBUG(2, __FUNCTION__ "(), not changing speed yet\n");
+                       IRDA_DEBUG(2, "%s(), not changing speed yet\n", __FUNCTION__);
                        *header = 0;
                        return;
                }
 
-               IRDA_DEBUG(2, __FUNCTION__ "(), changing speed to %d\n", self->new_speed);
+               IRDA_DEBUG(2, "%s(), changing speed to %d\n", __FUNCTION__, self->new_speed);
                self->speed = self->new_speed;
                /* We will do ` self->new_speed = -1; ' in the completion
                 * handler just in case the current URB fail - Jean II */
@@ -203,7 +203,7 @@ static void irda_usb_build_header(struct irda_usb_cb *self,
        
        /* Set the negotiated additional XBOFS */
        if (self->new_xbofs != -1) {
-               IRDA_DEBUG(2, __FUNCTION__ "(), changing xbofs to %d\n", self->new_xbofs);
+               IRDA_DEBUG(2, "%s(), changing xbofs to %d\n", __FUNCTION__, self->new_xbofs);
                self->xbofs = self->new_xbofs;
                /* We will do ` self->new_xbofs = -1; ' in the completion
                 * handler just in case the current URB fail - Jean II */
@@ -251,13 +251,13 @@ static void irda_usb_change_speed_xbofs(struct irda_usb_cb *self)
        struct urb *urb;
        int ret;
 
-       IRDA_DEBUG(2, __FUNCTION__ "(), speed=%d, xbofs=%d\n",
+       IRDA_DEBUG(2, "%s(), speed=%d, xbofs=%d\n", __FUNCTION__,
                   self->new_speed, self->new_xbofs);
 
        /* Grab the speed URB */
        urb = self->speed_urb;
        if (urb->status != 0) {
-               WARNING(__FUNCTION__ "(), URB still in use!\n");
+               WARNING("%s(), URB still in use!\n", __FUNCTION__);
                return;
        }
 
@@ -278,7 +278,7 @@ static void irda_usb_change_speed_xbofs(struct irda_usb_cb *self)
 
        /* Irq disabled -> GFP_ATOMIC */
        if ((ret = usb_submit_urb(urb, GFP_ATOMIC))) {
-               WARNING(__FUNCTION__ "(), failed Speed URB\n");
+               WARNING("%s(), failed Speed URB\n", __FUNCTION__);
        }
 }
 
@@ -291,7 +291,7 @@ static void speed_bulk_callback(struct urb *urb)
 {
        struct irda_usb_cb *self = urb->context;
        
-       IRDA_DEBUG(2, __FUNCTION__ "()\n");
+       IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
 
        /* We should always have a context */
        ASSERT(self != NULL, return;);
@@ -301,7 +301,7 @@ static void speed_bulk_callback(struct urb *urb)
        /* Check for timeout and other USB nasties */
        if (urb->status != 0) {
                /* I get a lot of -ECONNABORTED = -103 here - Jean II */
-               IRDA_DEBUG(0, __FUNCTION__ "(), URB complete status %d, transfer_flags 0x%04X\n", urb->status, urb->transfer_flags);
+               IRDA_DEBUG(0, "%s(), URB complete status %d, transfer_flags 0x%04X\n", __FUNCTION__, urb->status, urb->transfer_flags);
 
                /* Don't do anything here, that might confuse the USB layer.
                 * Instead, we will wait for irda_usb_net_timeout(), the
@@ -336,7 +336,7 @@ static int irda_usb_hard_xmit(struct sk_buff *skb, struct net_device *netdev)
        int res, mtt;
        int     err = 1;        /* Failed */
 
-       IRDA_DEBUG(4, __FUNCTION__ "() on %s\n", netdev->name);
+       IRDA_DEBUG(4, "%s() on %s\n", __FUNCTION__, netdev->name);
 
        netif_stop_queue(netdev);
 
@@ -347,7 +347,7 @@ static int irda_usb_hard_xmit(struct sk_buff *skb, struct net_device *netdev)
         * We need to check self->present under the spinlock because
         * of irda_usb_disconnect() is synchronous - Jean II */
        if (!self->present) {
-               IRDA_DEBUG(0, __FUNCTION__ "(), Device is gone...\n");
+               IRDA_DEBUG(0, "%s(), Device is gone...\n", __FUNCTION__);
                goto drop;
        }
 
@@ -381,7 +381,7 @@ static int irda_usb_hard_xmit(struct sk_buff *skb, struct net_device *netdev)
        }
 
        if (urb->status != 0) {
-               WARNING(__FUNCTION__ "(), URB still in use!\n");
+               WARNING("%s(), URB still in use!\n", __FUNCTION__);
                goto drop;
        }
 
@@ -390,9 +390,9 @@ static int irda_usb_hard_xmit(struct sk_buff *skb, struct net_device *netdev)
         * Also, we don't use directly skb_cow(), because it require
         * headroom >= 16, which force unnecessary copies - Jean II */
        if (skb_headroom(skb) < USB_IRDA_HEADER) {
-               IRDA_DEBUG(0, __FUNCTION__ "(), Insuficient skb headroom.\n");
+               IRDA_DEBUG(0, "%s(), Insuficient skb headroom.\n", __FUNCTION__);
                if (skb_cow(skb, USB_IRDA_HEADER)) {
-                       WARNING(__FUNCTION__ "(), failed skb_cow() !!!\n");
+                       WARNING("%s(), failed skb_cow() !!!\n", __FUNCTION__);
                        goto drop;
                }
        }
@@ -463,7 +463,7 @@ static int irda_usb_hard_xmit(struct sk_buff *skb, struct net_device *netdev)
        
        /* Ask USB to send the packet - Irq disabled -> GFP_ATOMIC */
        if ((res = usb_submit_urb(urb, GFP_ATOMIC))) {
-               WARNING(__FUNCTION__ "(), failed Tx URB\n");
+               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);*/
@@ -495,7 +495,7 @@ static void write_bulk_callback(struct urb *urb)
        struct sk_buff *skb = urb->context;
        struct irda_usb_cb *self = ((struct irda_skb_cb *) skb->cb)->context;
        
-       IRDA_DEBUG(2, __FUNCTION__ "()\n");
+       IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
 
        /* We should always have a context */
        ASSERT(self != NULL, return;);
@@ -509,7 +509,7 @@ static void write_bulk_callback(struct urb *urb)
        /* Check for timeout and other USB nasties */
        if (urb->status != 0) {
                /* I get a lot of -ECONNABORTED = -103 here - Jean II */
-               IRDA_DEBUG(0, __FUNCTION__ "(), URB complete status %d, transfer_flags 0x%04X\n", urb->status, urb->transfer_flags);
+               IRDA_DEBUG(0, "%s(), URB complete status %d, transfer_flags 0x%04X\n", __FUNCTION__, urb->status, urb->transfer_flags);
 
                /* Don't do anything here, that might confuse the USB layer,
                 * and we could go in recursion and blow the kernel stack...
@@ -528,7 +528,7 @@ static void write_bulk_callback(struct urb *urb)
 
        /* If the network is closed, stop everything */
        if ((!self->netopen) || (!self->present)) {
-               IRDA_DEBUG(0, __FUNCTION__ "(), Network is gone...\n");
+               IRDA_DEBUG(0, "%s(), Network is gone...\n", __FUNCTION__);
                spin_unlock_irqrestore(&self->lock, flags);
                return;
        }
@@ -539,7 +539,7 @@ static void write_bulk_callback(struct urb *urb)
                    (self->new_xbofs != self->xbofs)) {
                        /* We haven't changed speed yet (because of
                         * IUC_SPEED_BUG), so do it now - Jean II */
-                       IRDA_DEBUG(1, __FUNCTION__ "(), Changing speed now...\n");
+                       IRDA_DEBUG(1, "%s(), Changing speed now...\n", __FUNCTION__);
                        irda_usb_change_speed_xbofs(self);
                } else {
                        /* New speed and xbof is now commited in hardware */
@@ -571,7 +571,7 @@ static void irda_usb_net_timeout(struct net_device *netdev)
        struct urb *urb;
        int     done = 0;       /* If we have made any progress */
 
-       IRDA_DEBUG(0, __FUNCTION__ "(), Network layer thinks we timed out!\n");
+       IRDA_DEBUG(0, "%s(), Network layer thinks we timed out!\n", __FUNCTION__);
        ASSERT(self != NULL, return;);
 
        /* Protect us from USB callbacks, net Tx and else. */
@@ -579,7 +579,7 @@ static void irda_usb_net_timeout(struct net_device *netdev)
 
        /* self->present *MUST* be read under spinlock */
        if (!self->present) {
-               WARNING(__FUNCTION__ "(), device not present!\n");
+               WARNING("%s(), device not present!\n", __FUNCTION__);
                netif_stop_queue(netdev);
                spin_unlock_irqrestore(&self->lock, flags);
                return;
@@ -702,11 +702,11 @@ static void irda_usb_submit(struct irda_usb_cb *self, struct sk_buff *skb, struc
        struct irda_skb_cb *cb;
        int ret;
 
-       IRDA_DEBUG(2, __FUNCTION__ "()\n");
+       IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
 
        /* Check that we have an urb */
        if (!urb) {
-               WARNING(__FUNCTION__ "(), Bug : urb == NULL\n");
+               WARNING("%s(), Bug : urb == NULL\n", __FUNCTION__);
                return;
        }
 
@@ -716,7 +716,7 @@ static void irda_usb_submit(struct irda_usb_cb *self, struct sk_buff *skb, struc
                if (!skb) {
                        /* If this ever happen, we are in deep s***.
                         * Basically, the Rx path will stop... */
-                       WARNING(__FUNCTION__ "(), Failed to allocate Rx skb\n");
+                       WARNING("%s(), Failed to allocate Rx skb\n", __FUNCTION__);
                        return;
                }
        } else  {
@@ -745,7 +745,7 @@ static void irda_usb_submit(struct irda_usb_cb *self, struct sk_buff *skb, struc
        if (ret) {
                /* If this ever happen, we are in deep s***.
                 * Basically, the Rx path will stop... */
-               WARNING(__FUNCTION__ "(), Failed to submit Rx URB %d\n", ret);
+               WARNING("%s(), Failed to submit Rx URB %d\n", __FUNCTION__, ret);
        }
 }
 
@@ -763,7 +763,7 @@ static void irda_usb_receive(struct urb *urb)
        struct irda_skb_cb *cb;
        struct sk_buff *new;
        
-       IRDA_DEBUG(2, __FUNCTION__ "(), len=%d\n", urb->actual_length);
+       IRDA_DEBUG(2, "%s(), len=%d\n", __FUNCTION__, urb->actual_length);
        
        /* Find ourselves */
        cb = (struct irda_skb_cb *) skb->cb;
@@ -773,7 +773,7 @@ static void irda_usb_receive(struct urb *urb)
 
        /* If the network is closed or the device gone, stop everything */
        if ((!self->netopen) || (!self->present)) {
-               IRDA_DEBUG(0, __FUNCTION__ "(), Network is gone!\n");
+               IRDA_DEBUG(0, "%s(), Network is gone!\n", __FUNCTION__);
                /* Don't re-submit the URB : will stall the Rx path */
                return;
        }
@@ -786,13 +786,13 @@ static void irda_usb_receive(struct urb *urb)
                        self->stats.rx_crc_errors++;    
                        break;
                case -ECONNRESET:               /* -104 */
-                       IRDA_DEBUG(0, __FUNCTION__ "(), Connection Reset (-104), transfer_flags 0x%04X \n", urb->transfer_flags);
+                       IRDA_DEBUG(0, "%s(), Connection Reset (-104), transfer_flags 0x%04X \n", __FUNCTION__, urb->transfer_flags);
                        /* uhci_cleanup_unlink() is going to kill the Rx
                         * URB just after we return. No problem, at this
                         * point the URB will be idle ;-) - Jean II */
                        break;
                default:
-                       IRDA_DEBUG(0, __FUNCTION__ "(), RX status %d,transfer_flags 0x%04X \n", urb->status, urb->transfer_flags);
+                       IRDA_DEBUG(0, "%s(), RX status %d,transfer_flags 0x%04X \n", __FUNCTION__, urb->status, urb->transfer_flags);
                        break;
                }
                goto done;
@@ -800,7 +800,7 @@ static void irda_usb_receive(struct urb *urb)
        
        /* Check for empty frames */
        if (urb->actual_length <= USB_IRDA_HEADER) {
-               WARNING(__FUNCTION__ "(), empty frame!\n");
+               WARNING("%s(), empty frame!\n", __FUNCTION__);
                goto done;
        }
 
@@ -905,7 +905,7 @@ static int irda_usb_is_receiving(struct irda_usb_cb *self)
  */
 static int irda_usb_net_init(struct net_device *dev)
 {
-       IRDA_DEBUG(1, __FUNCTION__ "()\n");
+       IRDA_DEBUG(1, "%s()\n", __FUNCTION__);
        
        /* Set up to be a normal IrDA network device driver */
        irda_device_setup(dev);
@@ -929,7 +929,7 @@ static int irda_usb_net_open(struct net_device *netdev)
        char    hwname[16];
        int i;
        
-       IRDA_DEBUG(1, __FUNCTION__ "()\n");
+       IRDA_DEBUG(1, "%s()\n", __FUNCTION__);
 
        ASSERT(netdev != NULL, return -1;);
        self = (struct irda_usb_cb *) netdev->priv;
@@ -937,7 +937,7 @@ static int irda_usb_net_open(struct net_device *netdev)
 
        /* Can only open the device if it's there */
        if(!self->present) {
-               WARNING(__FUNCTION__ "(), device not present!\n");
+               WARNING("%s(), device not present!\n", __FUNCTION__);
                return -1;
        }
 
@@ -993,7 +993,7 @@ static int irda_usb_net_close(struct net_device *netdev)
        struct irda_usb_cb *self;
        int     i;
 
-       IRDA_DEBUG(1, __FUNCTION__ "()\n");
+       IRDA_DEBUG(1, "%s()\n", __FUNCTION__);
 
        ASSERT(netdev != NULL, return -1;);
        self = (struct irda_usb_cb *) netdev->priv;
@@ -1049,7 +1049,7 @@ static int irda_usb_net_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
        self = dev->priv;
        ASSERT(self != NULL, return -1;);
 
-       IRDA_DEBUG(2, __FUNCTION__ "(), %s, (cmd=0x%X)\n", dev->name, cmd);
+       IRDA_DEBUG(2, "%s(), %s, (cmd=0x%X)\n", __FUNCTION__, dev->name, cmd);
 
        switch (cmd) {
        case SIOCSBANDWIDTH: /* Set bandwidth */
@@ -1107,7 +1107,7 @@ static inline void irda_usb_init_qos(struct irda_usb_cb *self)
 {
        struct irda_class_desc *desc;
 
-       IRDA_DEBUG(3, __FUNCTION__ "()\n");
+       IRDA_DEBUG(3, "%s()\n", __FUNCTION__);
        
        desc = self->irda_desc;
        
@@ -1120,7 +1120,8 @@ static inline void irda_usb_init_qos(struct irda_usb_cb *self)
        self->qos.window_size.bits     = desc->bmWindowSize;
        self->qos.data_size.bits       = desc->bmDataSize;
 
-       IRDA_DEBUG(0, __FUNCTION__ "(), dongle says speed=0x%X, size=0x%X, window=0x%X, bofs=0x%X, turn=0x%X\n", self->qos.baud_rate.bits, self->qos.data_size.bits, self->qos.window_size.bits, self->qos.additional_bofs.bits, self->qos.min_turn_time.bits);
+       IRDA_DEBUG(0, "%s(), dongle says speed=0x%X, size=0x%X, window=0x%X, bofs=0x%X, turn=0x%X\n", 
+               __FUNCTION__, self->qos.baud_rate.bits, self->qos.data_size.bits, self->qos.window_size.bits, self->qos.additional_bofs.bits, self->qos.min_turn_time.bits);
 
        /* Don't always trust what the dongle tell us */
        if(self->capability & IUC_SIR_ONLY)
@@ -1164,7 +1165,7 @@ static inline int irda_usb_open(struct irda_usb_cb *self)
        struct net_device *netdev;
        int err;
 
-       IRDA_DEBUG(1, __FUNCTION__ "()\n");
+       IRDA_DEBUG(1, "%s()\n", __FUNCTION__);
 
        spin_lock_init(&self->lock);
 
@@ -1184,7 +1185,7 @@ static inline int irda_usb_open(struct irda_usb_cb *self)
 
        /* Create a network device for us */
        if (!(netdev = dev_alloc("irda%d", &err))) {
-               ERROR(__FUNCTION__ "(), dev_alloc() failed!\n");
+               ERROR("%s(), dev_alloc() failed!\n", __FUNCTION__);
                return -1;
        }
        self->netdev = netdev;
@@ -1204,7 +1205,7 @@ static inline int irda_usb_open(struct irda_usb_cb *self)
        err = register_netdevice(netdev);
        rtnl_unlock();
        if (err) {
-               ERROR(__FUNCTION__ "(), register_netdev() failed!\n");
+               ERROR("%s(), register_netdev() failed!\n", __FUNCTION__);
                return -1;
        }
        MESSAGE("IrDA: Registered device %s\n", netdev->name);
@@ -1219,7 +1220,7 @@ static inline int irda_usb_open(struct irda_usb_cb *self)
  */
 static inline int irda_usb_close(struct irda_usb_cb *self)
 {
-       IRDA_DEBUG(1, __FUNCTION__ "()\n");
+       IRDA_DEBUG(1, "%s()\n", __FUNCTION__);
 
        ASSERT(self != NULL, return -1;);
 
@@ -1301,12 +1302,13 @@ static inline int irda_usb_parse_endpoints(struct irda_usb_cb *self, struct usb_
                                /* This is our interrupt endpoint */
                                self->bulk_int_ep = ep;
                        } else {
-                               ERROR(__FUNCTION__ "(), Unrecognised endpoint %02X.\n", ep);
+                               ERROR("%s(), Unrecognised endpoint %02X.\n", __FUNCTION__, ep);
                        }
                }
        }
 
-       IRDA_DEBUG(0, __FUNCTION__ "(), And our endpoints are : in=%02X, out=%02X (%d), int=%02X\n", self->bulk_in_ep, self->bulk_out_ep, self->bulk_out_mtu, self->bulk_int_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, ;);
 
@@ -1368,7 +1370,7 @@ static inline struct irda_class_desc *irda_usb_find_class_desc(struct usb_device
                USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
                0, ifnum, desc, sizeof(*desc), MSECS_TO_JIFFIES(500));
        
-       IRDA_DEBUG(1, __FUNCTION__ "(), ret=%d\n", ret);
+       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);
@@ -1427,7 +1429,7 @@ static void *irda_usb_probe(struct usb_device *dev, unsigned int ifnum,
                if((irda->usbdev != NULL) &&
                   (irda->present == 0) &&
                   (irda->netopen == 0)) {
-                       IRDA_DEBUG(0, __FUNCTION__ "(), found a zombie instance !!!\n");
+                       IRDA_DEBUG(0, "%s(), found a zombie instance !!!\n", __FUNCTION__);
                        irda_usb_disconnect(irda->usbdev, (void *) irda);
                }
        }
@@ -1491,10 +1493,10 @@ static void *irda_usb_probe(struct usb_device *dev, unsigned int ifnum,
                        break;
                case -EPIPE:            /* -EPIPE = -32 */
                        usb_clear_halt(dev, usb_sndctrlpipe(dev, 0));
-                       IRDA_DEBUG(0, __FUNCTION__ "(), Clearing stall on control interface\n" );
+                       IRDA_DEBUG(0, "%s(), Clearing stall on control interface\n", __FUNCTION__);
                        break;
                default:
-                       IRDA_DEBUG(0, __FUNCTION__ "(), Unknown error %d\n", ret);
+                       IRDA_DEBUG(0, "%s(), Unknown error %d\n", __FUNCTION__, ret);
                        return NULL;
                        break;
        }
@@ -1503,7 +1505,7 @@ static void *irda_usb_probe(struct usb_device *dev, unsigned int ifnum,
        interface = &dev->actconfig->interface[ifnum].altsetting[0];
        if(!irda_usb_parse_endpoints(self, interface->endpoint,
                                     interface->bNumEndpoints)) {
-               ERROR(__FUNCTION__ "(), Bogus endpoints...\n");
+               ERROR("%s(), Bogus endpoints...\n", __FUNCTION__);
                return NULL;
        }
 
@@ -1542,7 +1544,7 @@ static void irda_usb_disconnect(struct usb_device *dev, void *ptr)
        struct irda_usb_cb *self = (struct irda_usb_cb *) ptr;
        int i;
 
-       IRDA_DEBUG(1, __FUNCTION__ "()\n");
+       IRDA_DEBUG(1, "%s()\n", __FUNCTION__);
 
        /* Make sure that the Tx path is not executing. - Jean II */
        spin_lock_irqsave(&self->lock, flags);
@@ -1583,7 +1585,7 @@ static void irda_usb_disconnect(struct usb_device *dev, void *ptr)
        usb_free_urb(self->tx_urb);
        usb_free_urb(self->speed_urb);
 
-       IRDA_DEBUG(0, __FUNCTION__ "(), USB IrDA Disconnected\n");
+       IRDA_DEBUG(0, "%s(), USB IrDA Disconnected\n", __FUNCTION__);
 }
 
 /*------------------------------------------------------------------*/
@@ -1632,7 +1634,7 @@ void __exit usb_irda_cleanup(void)
                irda = &irda_instance[i];
                /* If the Device is zombie */
                if((irda->usbdev != NULL) && (irda->present == 0)) {
-                       IRDA_DEBUG(0, __FUNCTION__ "(), disconnect zombie now !\n");
+                       IRDA_DEBUG(0, "%s(), disconnect zombie now !\n", __FUNCTION__);
                        irda_usb_disconnect(irda->usbdev, (void *) irda);
                }
        }

diff --git a/drivers/net/irda/irtty.c b/drivers/net/irda/irtty.c
index 0ad7244decbc6f5a8462c8dacb0cca2d61da88b7..75f2d5fe9d30d24ba9a8644190e4fbb0f098c16e 100644 (file)
--- a/drivers/net/irda/irtty.c
+++ b/drivers/net/irda/irtty.c
@@ -356,7 +356,7 @@ static void __irtty_change_speed(struct irtty_cb *self, __u32 speed)
 
        cflag &= ~CBAUD;
 
-       IRDA_DEBUG(2, __FUNCTION__ "(), Setting speed to %d\n", speed);
+       IRDA_DEBUG(2, "%s(), Setting speed to %d\n", __FUNCTION__, speed);
 
        switch (speed) {
        case 1200:
@@ -406,7 +406,7 @@ static int irtty_change_speed(struct irda_task *task)
        __u32 speed = (__u32) task->param;
        int ret = 0;
 
-       IRDA_DEBUG(2, __FUNCTION__ "(), <%ld>\n", jiffies); 
+       IRDA_DEBUG(2, "%s(), <%ld>\n", __FUNCTION__, jiffies); 
 
        self = (struct irtty_cb *) task->instance;
        ASSERT(self != NULL, return -1;);
@@ -416,7 +416,7 @@ static int irtty_change_speed(struct irda_task *task)
 
        /* Check if busy */
        if (self->task && self->task != task) {
-               IRDA_DEBUG(0, __FUNCTION__ "(), busy!\n");
+               IRDA_DEBUG(0, "%s(), busy!\n", __FUNCTION__);
                spin_unlock_irqrestore(&self->lock, flags);
                return MSECS_TO_JIFFIES(10);
        } else
@@ -571,7 +571,7 @@ static void irtty_receive_buf(struct tty_struct *tty, const unsigned char *cp,
        struct irtty_cb *self = (struct irtty_cb *) tty->disc_data;
 
        if (!self || !self->netdev) {
-               IRDA_DEBUG(0, __FUNCTION__ "(), not ready yet!\n");
+               IRDA_DEBUG(0, "%s(), not ready yet!\n", __FUNCTION__);
                return;
        }
 
@@ -621,7 +621,7 @@ static int irtty_change_speed_complete(struct irda_task *task)
 {
        struct irtty_cb *self;
 
-       IRDA_DEBUG(2, __FUNCTION__ "()\n");
+       IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
 
        self = (struct irtty_cb *) task->instance;
 
@@ -707,7 +707,7 @@ static int irtty_hard_xmit(struct sk_buff *skb, struct net_device *dev)
 */
 static int irtty_receive_room(struct tty_struct *tty) 
 {
-       IRDA_DEBUG(0, __FUNCTION__ "()\n");
+       IRDA_DEBUG(0, "%s()\n", __FUNCTION__);
        return 65536;  /* We can handle an infinite amount of data. :-) */
 }
 
@@ -749,7 +749,7 @@ static void irtty_write_wakeup(struct tty_struct *tty)
                 *  Now serial buffer is almost free & we can start 
                 *  transmission of another packet 
                 */
-               IRDA_DEBUG(5, __FUNCTION__ "(), finished with frame!\n");
+               IRDA_DEBUG(5, "%s(), finished with frame!\n", __FUNCTION__);
                
                self->stats.tx_packets++;                     
 
@@ -759,7 +759,7 @@ static void irtty_write_wakeup(struct tty_struct *tty)
                spin_unlock_irqrestore(&self->lock, flags);
 
                if (self->new_speed) {
-                       IRDA_DEBUG(5, __FUNCTION__ "(), Changing speed!\n");
+                       IRDA_DEBUG(5, "%s(), Changing speed!\n", __FUNCTION__);
                        irda_task_execute(self, irtty_change_speed, 
                                          irtty_change_speed_complete, 
                                          NULL, (void *) self->new_speed);
@@ -824,7 +824,7 @@ static int irtty_set_dtr_rts(struct net_device *dev, int dtr, int rts)
        
        /* This is probably unsafe, but currently under discussion - Jean II */
        if (tty->driver.ioctl(tty, NULL, TIOCMSET, (unsigned long) &arg)) { 
-               IRDA_DEBUG(2, __FUNCTION__ "(), error doing ioctl!\n");
+               IRDA_DEBUG(2, "%s(), error doing ioctl!\n", __FUNCTION__);
        }
        set_fs(fs);
 
@@ -850,7 +850,7 @@ int irtty_set_mode(struct net_device *dev, int mode)
 
        ASSERT(self != NULL, return -1;);
 
-       IRDA_DEBUG(2, __FUNCTION__ "(), mode=%s\n", infrared_mode[mode]);
+       IRDA_DEBUG(2, "%s(), mode=%s\n", __FUNCTION__, infrared_mode[mode]);
 
        /* Protect access to self->rx_buff - Jean II */
        spin_lock_irqsave(&self->lock, flags);
@@ -948,7 +948,7 @@ static int irtty_net_open(struct net_device *dev)
        ASSERT(self != NULL, return -1;);
        ASSERT(self->magic == IRTTY_MAGIC, return -1;);
 
-       IRDA_DEBUG(0, __FUNCTION__ "()\n");
+       IRDA_DEBUG(0, "%s()\n", __FUNCTION__);
        
        /* Ready to play! */
        netif_start_queue(dev);
@@ -1015,7 +1015,7 @@ static int irtty_net_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
        ASSERT(self != NULL, return -1;);
        ASSERT(self->magic == IRTTY_MAGIC, return -1;);
 
-       IRDA_DEBUG(3, __FUNCTION__ "(), %s, (cmd=0x%X)\n", dev->name, cmd);
+       IRDA_DEBUG(3, "%s(), %s, (cmd=0x%X)\n", __FUNCTION__, dev->name, cmd);
        
        /* Locking :
         * irda_device_dongle_init() can't be locked.

diff --git a/drivers/net/irda/nsc-ircc.c b/drivers/net/irda/nsc-ircc.c
index 9437db203e089c22fc767eda8b483ed771aebd6a..63748b7bbe329e74e8ead72285beaaf7658495b2 100644 (file)
--- a/drivers/net/irda/nsc-ircc.c
+++ b/drivers/net/irda/nsc-ircc.c
@@ -921,8 +921,8 @@ static void nsc_ircc_change_dongle_speed(int iobase, int speed, int dongle_id)
                break;
        case 0x0A: /* same as */
        case 0x0B: /* Reserved */
-               IRDA_DEBUG(0, __FUNCTION__ "(), %s not defined by irda yet\n",
-                          dongle_types[dongle_id]); 
+               IRDA_DEBUG(0, "%s(), %s not defined by irda yet\n",
+                          __FUNCTION__, dongle_types[dongle_id]); 
                break;
        case 0x0C: /* same as */
        case 0x0D: /* HP HSDL-1100/HSDL-2100 */
@@ -930,14 +930,14 @@ static void nsc_ircc_change_dongle_speed(int iobase, int speed, int dongle_id)
        case 0x0E: /* Supports SIR Mode only */
                break;
        case 0x0F: /* No dongle connected */
-               IRDA_DEBUG(0, __FUNCTION__ "(), %s is not for IrDA mode\n",
-                          dongle_types[dongle_id]);
+               IRDA_DEBUG(0, "%s(), %s is not for IrDA mode\n",
+                          __FUNCTION__, dongle_types[dongle_id]);
 
                switch_bank(iobase, BANK0); 
                outb(0x62, iobase+MCR);
                break;
        default: 
-               IRDA_DEBUG(0, __FUNCTION__ "(), invalid data_rate\n");
+               IRDA_DEBUG(0, "%s(), invalid data_rate\n", __FUNCTION__);
        }
        /* Restore bank register */
        outb(bank, iobase+BSR);
@@ -958,7 +958,7 @@ static __u8 nsc_ircc_change_speed(struct nsc_ircc_cb *self, __u32 speed)
        __u8 bank;
        __u8 ier;                  /* Interrupt enable register */
 
-       IRDA_DEBUG(2, __FUNCTION__ "(), speed=%d\n", speed);
+       IRDA_DEBUG(2, "%s(), speed=%d\n", __FUNCTION__, speed);
 
        ASSERT(self != NULL, return 0;);
 
@@ -991,20 +991,20 @@ static __u8 nsc_ircc_change_speed(struct nsc_ircc_cb *self, __u32 speed)
                outb(inb(iobase+4) | 0x04, iobase+4);
               
                mcr = MCR_MIR;
-               IRDA_DEBUG(0, __FUNCTION__ "(), handling baud of 576000\n");
+               IRDA_DEBUG(0, "%s(), handling baud of 576000\n", __FUNCTION__);
                break;
        case 1152000:
                mcr = MCR_MIR;
-               IRDA_DEBUG(0, __FUNCTION__ "(), handling baud of 1152000\n");
+               IRDA_DEBUG(0, "%s(), handling baud of 1152000\n", __FUNCTION__);
                break;
        case 4000000:
                mcr = MCR_FIR;
-               IRDA_DEBUG(0, __FUNCTION__ "(), handling baud of 4000000\n");
+               IRDA_DEBUG(0, "%s(), handling baud of 4000000\n", __FUNCTION__);
                break;
        default:
                mcr = MCR_FIR;
-               IRDA_DEBUG(0, __FUNCTION__ "(), unknown baud rate of %d\n", 
-                          speed);
+               IRDA_DEBUG(0, "%s(), unknown baud rate of %d\n", 
+                          __FUNCTION__, speed);
                break;
        }
 
@@ -1305,15 +1305,15 @@ static int nsc_ircc_pio_write(int iobase, __u8 *buf, int len, int fifo_size)
        int actual = 0;
        __u8 bank;
        
-       IRDA_DEBUG(4, __FUNCTION__ "()\n");
+       IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
 
        /* Save current bank */
        bank = inb(iobase+BSR);
 
        switch_bank(iobase, BANK0);
        if (!(inb_p(iobase+LSR) & LSR_TXEMP)) {
-               IRDA_DEBUG(4, __FUNCTION__ 
-                          "(), warning, FIFO not empty yet!\n");
+               IRDA_DEBUG(4, "%s(), warning, FIFO not empty yet!\n",
+                          __FUNCTION__);
 
                /* FIFO may still be filled to the Tx interrupt threshold */
                fifo_size -= 17;
@@ -1325,8 +1325,8 @@ static int nsc_ircc_pio_write(int iobase, __u8 *buf, int len, int fifo_size)
                outb(buf[actual++], iobase+TXD);
        }
         
-       IRDA_DEBUG(4, __FUNCTION__ "(), fifo_size %d ; %d sent of %d\n", 
-                  fifo_size, actual, len);
+       IRDA_DEBUG(4, "%s(), fifo_size %d ; %d sent of %d\n", 
+                  __FUNCTION__, fifo_size, actual, len);
        
        /* Restore bank */
        outb(bank, iobase+BSR);
@@ -1347,7 +1347,7 @@ static int nsc_ircc_dma_xmit_complete(struct nsc_ircc_cb *self)
        __u8 bank;
        int ret = TRUE;
 
-       IRDA_DEBUG(2, __FUNCTION__ "()\n");
+       IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
 
        iobase = self->io.fir_base;
 
@@ -1478,7 +1478,7 @@ static int nsc_ircc_dma_receive_complete(struct nsc_ircc_cb *self, int iobase)
                len = inb(iobase+RFLFL) | ((inb(iobase+RFLFH) & 0x1f) << 8);
 
                if (st_fifo->tail >= MAX_RX_WINDOW) {
-                       IRDA_DEBUG(0, __FUNCTION__ "(), window is full!\n");
+                       IRDA_DEBUG(0, "%s(), window is full!\n", __FUNCTION__);
                        continue;
                }
                        
@@ -1671,7 +1671,7 @@ static void nsc_ircc_sir_interrupt(struct nsc_ircc_cb *self, int eir)
                 * Need to be after self->io.direction to avoid race with
                 * nsc_ircc_hard_xmit_sir() - Jean II */
                if (self->new_speed) {
-                       IRDA_DEBUG(2, __FUNCTION__ "(), Changing speed!\n");
+                       IRDA_DEBUG(2, "%s(), Changing speed!\n", __FUNCTION__);
                        self->ier = nsc_ircc_change_speed(self,
                                                          self->new_speed);
                        self->new_speed = 0;
@@ -1755,8 +1755,9 @@ static void nsc_ircc_fir_interrupt(struct nsc_ircc_cb *self, int iobase,
                                        nsc_ircc_dma_receive(self);
                                        self->ier = IER_SFIF_IE;
                                } else
-                                       WARNING(__FUNCTION__ "(), potential "
-                                               "Tx queue lockup !\n");
+                                       WARNING("%s(), potential "
+                                               "Tx queue lockup !\n",
+                                               __FUNCTION__);
                        }
                } else {
                        /*  Not finished yet, so interrupt on DMA again */
@@ -1863,7 +1864,7 @@ static int nsc_ircc_is_receiving(struct nsc_ircc_cb *self)
  */
 static int nsc_ircc_net_init(struct net_device *dev)
 {
-       IRDA_DEBUG(4, __FUNCTION__ "()\n");
+       IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
 
        /* Setup to be a normal IrDA network device driver */
        irda_device_setup(dev);
@@ -1886,7 +1887,7 @@ static int nsc_ircc_net_open(struct net_device *dev)
        char hwname[32];
        __u8 bank;
        
-       IRDA_DEBUG(4, __FUNCTION__ "()\n");
+       IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
        
        ASSERT(dev != NULL, return -1;);
        self = (struct nsc_ircc_cb *) dev->priv;
@@ -1950,7 +1951,7 @@ static int nsc_ircc_net_close(struct net_device *dev)
        int iobase;
        __u8 bank;
 
-       IRDA_DEBUG(4, __FUNCTION__ "()\n");
+       IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
        
        ASSERT(dev != NULL, return -1;);
 
@@ -2006,7 +2007,7 @@ static int nsc_ircc_net_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
 
        ASSERT(self != NULL, return -1;);
 
-       IRDA_DEBUG(2, __FUNCTION__ "(), %s, (cmd=0x%X)\n", dev->name, cmd);
+       IRDA_DEBUG(2, "%s(), %s, (cmd=0x%X)\n", __FUNCTION__, dev->name, cmd);
        
        switch (cmd) {
        case SIOCSBANDWIDTH: /* Set bandwidth */