USB: replace remaining __FUNCTION__ occurrences
Harvey Harrison [Tue, 4 Mar 2008 00:08:34 +0000 (16:08 -0800)]
__FUNCTION__ is gcc-specific, use __func__

Signed-off-by: Harvey Harrison <harvey.harrison@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

83 files changed:
drivers/usb/atm/ueagle-atm.c
drivers/usb/class/cdc-acm.c
drivers/usb/core/devio.c
drivers/usb/core/driver.c
drivers/usb/core/hub.c
drivers/usb/core/inode.c
drivers/usb/core/message.c
drivers/usb/core/urb.c
drivers/usb/gadget/at91_udc.c
drivers/usb/gadget/dummy_hcd.c
drivers/usb/gadget/ether.c
drivers/usb/gadget/file_storage.c
drivers/usb/gadget/fsl_usb2_udc.c
drivers/usb/gadget/fsl_usb2_udc.h
drivers/usb/gadget/goku_udc.c
drivers/usb/gadget/inode.c
drivers/usb/gadget/lh7a40x_udc.c
drivers/usb/gadget/net2280.h
drivers/usb/gadget/omap_udc.c
drivers/usb/gadget/printer.c
drivers/usb/gadget/pxa2xx_udc.c
drivers/usb/gadget/rndis.c
drivers/usb/host/ehci-q.c
drivers/usb/host/ehci-sched.c
drivers/usb/host/pci-quirks.c
drivers/usb/host/sl811-hcd.c
drivers/usb/host/uhci-hcd.c
drivers/usb/host/uhci-q.c
drivers/usb/misc/adutux.c
drivers/usb/misc/appledisplay.c
drivers/usb/misc/auerswald.c
drivers/usb/misc/emi26.c
drivers/usb/misc/emi62.c
drivers/usb/misc/iowarrior.c
drivers/usb/misc/ldusb.c
drivers/usb/misc/legousbtower.c
drivers/usb/misc/phidgetkit.c
drivers/usb/misc/phidgetmotorcontrol.c
drivers/usb/misc/phidgetservo.c
drivers/usb/misc/usblcd.c
drivers/usb/misc/usbtest.c
drivers/usb/serial/aircable.c
drivers/usb/serial/airprime.c
drivers/usb/serial/ark3116.c
drivers/usb/serial/belkin_sa.c
drivers/usb/serial/console.c
drivers/usb/serial/cp2101.c
drivers/usb/serial/cyberjack.c
drivers/usb/serial/cypress_m8.c
drivers/usb/serial/digi_acceleport.c
drivers/usb/serial/empeg.c
drivers/usb/serial/ezusb.c
drivers/usb/serial/ftdi_sio.c
drivers/usb/serial/garmin_gps.c
drivers/usb/serial/generic.c
drivers/usb/serial/io_edgeport.c
drivers/usb/serial/io_ti.c
drivers/usb/serial/ipaq.c
drivers/usb/serial/ipw.c
drivers/usb/serial/ir-usb.c
drivers/usb/serial/iuu_phoenix.c
drivers/usb/serial/keyspan.c
drivers/usb/serial/keyspan_pda.c
drivers/usb/serial/kl5kusb105.c
drivers/usb/serial/kobil_sct.c
drivers/usb/serial/mct_u232.c
drivers/usb/serial/mos7720.c
drivers/usb/serial/mos7840.c
drivers/usb/serial/navman.c
drivers/usb/serial/omninet.c
drivers/usb/serial/option.c
drivers/usb/serial/oti6858.c
drivers/usb/serial/pl2303.c
drivers/usb/serial/safe_serial.c
drivers/usb/serial/sierra.c
drivers/usb/serial/ti_usb_3410_5052.c
drivers/usb/serial/usb-serial.c
drivers/usb/serial/visor.c
drivers/usb/serial/whiteheat.c
drivers/usb/storage/scsiglue.c
drivers/usb/storage/transport.c
drivers/usb/storage/usb.c
drivers/usb/usb-skeleton.c

index c5ec1a5..abb7d74 100644 (file)
@@ -83,7 +83,7 @@
                if (debug >= 1) \
                        dev_dbg(&(usb_dev)->dev, \
                                "[ueagle-atm dbg] %s: " format, \
-                                       __FUNCTION__, ##args); \
+                                       __func__, ##args); \
        } while (0)
 
 #define uea_vdbg(usb_dev, format, args...)     \
        } while (0)
 
 #define uea_enters(usb_dev) \
-       uea_vdbg(usb_dev, "entering %s\n", __FUNCTION__)
+       uea_vdbg(usb_dev, "entering %s\n", __func__)
 
 #define uea_leaves(usb_dev) \
-       uea_vdbg(usb_dev, "leaving  %s\n", __FUNCTION__)
+       uea_vdbg(usb_dev, "leaving  %s\n", __func__)
 
 #define uea_err(usb_dev, format,args...) \
        dev_err(&(usb_dev)->dev ,"[UEAGLE-ATM] " format , ##args)
index 6d57413..33cdf8f 100644 (file)
@@ -260,10 +260,10 @@ static void acm_ctrl_irq(struct urb *urb)
        case -ENOENT:
        case -ESHUTDOWN:
                /* this urb is terminated, clean up */
-               dbg("%s - urb shutting down with status: %d", __FUNCTION__, status);
+               dbg("%s - urb shutting down with status: %d", __func__, status);
                return;
        default:
-               dbg("%s - nonzero urb status received: %d", __FUNCTION__, status);
+               dbg("%s - nonzero urb status received: %d", __func__, status);
                goto exit;
        }
 
@@ -307,7 +307,7 @@ exit:
        retval = usb_submit_urb (urb, GFP_ATOMIC);
        if (retval)
                err ("%s - usb_submit_urb failed with result %d",
-                    __FUNCTION__, retval);
+                    __func__, retval);
 }
 
 /* data interface returns incoming bytes, or we got unthrottled */
index 6c4cd82..de17738 100644 (file)
@@ -1530,60 +1530,60 @@ static int usbdev_ioctl(struct inode *inode, struct file *file,
 
        switch (cmd) {
        case USBDEVFS_CONTROL:
-               snoop(&dev->dev, "%s: CONTROL\n", __FUNCTION__);
+               snoop(&dev->dev, "%s: CONTROL\n", __func__);
                ret = proc_control(ps, p);
                if (ret >= 0)
                        inode->i_mtime = CURRENT_TIME;
                break;
 
        case USBDEVFS_BULK:
-               snoop(&dev->dev, "%s: BULK\n", __FUNCTION__);
+               snoop(&dev->dev, "%s: BULK\n", __func__);
                ret = proc_bulk(ps, p);
                if (ret >= 0)
                        inode->i_mtime = CURRENT_TIME;
                break;
 
        case USBDEVFS_RESETEP:
-               snoop(&dev->dev, "%s: RESETEP\n", __FUNCTION__);
+               snoop(&dev->dev, "%s: RESETEP\n", __func__);
                ret = proc_resetep(ps, p);
                if (ret >= 0)
                        inode->i_mtime = CURRENT_TIME;
                break;
 
        case USBDEVFS_RESET:
-               snoop(&dev->dev, "%s: RESET\n", __FUNCTION__);
+               snoop(&dev->dev, "%s: RESET\n", __func__);
                ret = proc_resetdevice(ps);
                break;
 
        case USBDEVFS_CLEAR_HALT:
-               snoop(&dev->dev, "%s: CLEAR_HALT\n", __FUNCTION__);
+               snoop(&dev->dev, "%s: CLEAR_HALT\n", __func__);
                ret = proc_clearhalt(ps, p);
                if (ret >= 0)
                        inode->i_mtime = CURRENT_TIME;
                break;
 
        case USBDEVFS_GETDRIVER:
-               snoop(&dev->dev, "%s: GETDRIVER\n", __FUNCTION__);
+               snoop(&dev->dev, "%s: GETDRIVER\n", __func__);
                ret = proc_getdriver(ps, p);
                break;
 
        case USBDEVFS_CONNECTINFO:
-               snoop(&dev->dev, "%s: CONNECTINFO\n", __FUNCTION__);
+               snoop(&dev->dev, "%s: CONNECTINFO\n", __func__);
                ret = proc_connectinfo(ps, p);
                break;
 
        case USBDEVFS_SETINTERFACE:
-               snoop(&dev->dev, "%s: SETINTERFACE\n", __FUNCTION__);
+               snoop(&dev->dev, "%s: SETINTERFACE\n", __func__);
                ret = proc_setintf(ps, p);
                break;
 
        case USBDEVFS_SETCONFIGURATION:
-               snoop(&dev->dev, "%s: SETCONFIGURATION\n", __FUNCTION__);
+               snoop(&dev->dev, "%s: SETCONFIGURATION\n", __func__);
                ret = proc_setconfig(ps, p);
                break;
 
        case USBDEVFS_SUBMITURB:
-               snoop(&dev->dev, "%s: SUBMITURB\n", __FUNCTION__);
+               snoop(&dev->dev, "%s: SUBMITURB\n", __func__);
                ret = proc_submiturb(ps, p);
                if (ret >= 0)
                        inode->i_mtime = CURRENT_TIME;
@@ -1592,60 +1592,60 @@ static int usbdev_ioctl(struct inode *inode, struct file *file,
 #ifdef CONFIG_COMPAT
 
        case USBDEVFS_SUBMITURB32:
-               snoop(&dev->dev, "%s: SUBMITURB32\n", __FUNCTION__);
+               snoop(&dev->dev, "%s: SUBMITURB32\n", __func__);
                ret = proc_submiturb_compat(ps, p);
                if (ret >= 0)
                        inode->i_mtime = CURRENT_TIME;
                break;
 
        case USBDEVFS_REAPURB32:
-               snoop(&dev->dev, "%s: REAPURB32\n", __FUNCTION__);
+               snoop(&dev->dev, "%s: REAPURB32\n", __func__);
                ret = proc_reapurb_compat(ps, p);
                break;
 
        case USBDEVFS_REAPURBNDELAY32:
-               snoop(&dev->dev, "%s: REAPURBDELAY32\n", __FUNCTION__);
+               snoop(&dev->dev, "%s: REAPURBDELAY32\n", __func__);
                ret = proc_reapurbnonblock_compat(ps, p);
                break;
 
        case USBDEVFS_IOCTL32:
-               snoop(&dev->dev, "%s: IOCTL\n", __FUNCTION__);
+               snoop(&dev->dev, "%s: IOCTL\n", __func__);
                ret = proc_ioctl_compat(ps, ptr_to_compat(p));
                break;
 #endif
 
        case USBDEVFS_DISCARDURB:
-               snoop(&dev->dev, "%s: DISCARDURB\n", __FUNCTION__);
+               snoop(&dev->dev, "%s: DISCARDURB\n", __func__);
                ret = proc_unlinkurb(ps, p);
                break;
 
        case USBDEVFS_REAPURB:
-               snoop(&dev->dev, "%s: REAPURB\n", __FUNCTION__);
+               snoop(&dev->dev, "%s: REAPURB\n", __func__);
                ret = proc_reapurb(ps, p);
                break;
 
        case USBDEVFS_REAPURBNDELAY:
-               snoop(&dev->dev, "%s: REAPURBDELAY\n", __FUNCTION__);
+               snoop(&dev->dev, "%s: REAPURBDELAY\n", __func__);
                ret = proc_reapurbnonblock(ps, p);
                break;
 
        case USBDEVFS_DISCSIGNAL:
-               snoop(&dev->dev, "%s: DISCSIGNAL\n", __FUNCTION__);
+               snoop(&dev->dev, "%s: DISCSIGNAL\n", __func__);
                ret = proc_disconnectsignal(ps, p);
                break;
 
        case USBDEVFS_CLAIMINTERFACE:
-               snoop(&dev->dev, "%s: CLAIMINTERFACE\n", __FUNCTION__);
+               snoop(&dev->dev, "%s: CLAIMINTERFACE\n", __func__);
                ret = proc_claiminterface(ps, p);
                break;
 
        case USBDEVFS_RELEASEINTERFACE:
-               snoop(&dev->dev, "%s: RELEASEINTERFACE\n", __FUNCTION__);
+               snoop(&dev->dev, "%s: RELEASEINTERFACE\n", __func__);
                ret = proc_releaseinterface(ps, p);
                break;
 
        case USBDEVFS_IOCTL:
-               snoop(&dev->dev, "%s: IOCTL\n", __FUNCTION__);
+               snoop(&dev->dev, "%s: IOCTL\n", __func__);
                ret = proc_ioctl_default(ps, p);
                break;
        }
index edc31e1..1e56f1c 100644 (file)
@@ -157,7 +157,7 @@ static int usb_probe_device(struct device *dev)
        struct usb_device *udev;
        int error = -ENODEV;
 
-       dev_dbg(dev, "%s\n", __FUNCTION__);
+       dev_dbg(dev, "%s\n", __func__);
 
        if (!is_usb_device(dev))        /* Sanity check */
                return error;
@@ -194,7 +194,7 @@ static int usb_probe_interface(struct device *dev)
        const struct usb_device_id *id;
        int error = -ENODEV;
 
-       dev_dbg(dev, "%s\n", __FUNCTION__);
+       dev_dbg(dev, "%s\n", __func__);
 
        if (is_usb_device(dev))         /* Sanity check */
                return error;
@@ -211,7 +211,7 @@ static int usb_probe_interface(struct device *dev)
        if (!id)
                id = usb_match_dynamic_id(intf, driver);
        if (id) {
-               dev_dbg(dev, "%s - got id\n", __FUNCTION__);
+               dev_dbg(dev, "%s - got id\n", __func__);
 
                error = usb_autoresume_device(udev);
                if (error)
@@ -793,7 +793,7 @@ static int usb_suspend_device(struct usb_device *udev, pm_message_t msg)
        status = udriver->suspend(udev, msg);
 
  done:
-       dev_vdbg(&udev->dev, "%s: status %d\n", __FUNCTION__, status);
+       dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
        return status;
 }
 
@@ -821,7 +821,7 @@ static int usb_resume_device(struct usb_device *udev)
        status = udriver->resume(udev);
 
  done:
-       dev_vdbg(&udev->dev, "%s: status %d\n", __FUNCTION__, status);
+       dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
        if (status == 0)
                udev->autoresume_disabled = 0;
        return status;
@@ -860,7 +860,7 @@ static int usb_suspend_interface(struct usb_interface *intf, pm_message_t msg)
        }
 
  done:
-       dev_vdbg(&intf->dev, "%s: status %d\n", __FUNCTION__, status);
+       dev_vdbg(&intf->dev, "%s: status %d\n", __func__, status);
        return status;
 }
 
@@ -910,7 +910,7 @@ static int usb_resume_interface(struct usb_interface *intf, int reset_resume)
        }
 
 done:
-       dev_vdbg(&intf->dev, "%s: status %d\n", __FUNCTION__, status);
+       dev_vdbg(&intf->dev, "%s: status %d\n", __func__, status);
        if (status == 0)
                mark_active(intf);
 
@@ -1093,7 +1093,7 @@ static int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
        }
 
  done:
-       dev_vdbg(&udev->dev, "%s: status %d\n", __FUNCTION__, status);
+       dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
        return status;
 }
 
@@ -1187,7 +1187,7 @@ static int usb_resume_both(struct usb_device *udev)
        }
 
  done:
-       dev_vdbg(&udev->dev, "%s: status %d\n", __FUNCTION__, status);
+       dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
        if (!status)
                udev->reset_resume = 0;
        return status;
@@ -1257,7 +1257,7 @@ void usb_autosuspend_device(struct usb_device *udev)
 
        status = usb_autopm_do_device(udev, -1);
        dev_vdbg(&udev->dev, "%s: cnt %d\n",
-                       __FUNCTION__, udev->pm_usage_cnt);
+                       __func__, udev->pm_usage_cnt);
 }
 
 /**
@@ -1277,7 +1277,7 @@ void usb_try_autosuspend_device(struct usb_device *udev)
 {
        usb_autopm_do_device(udev, 0);
        dev_vdbg(&udev->dev, "%s: cnt %d\n",
-                       __FUNCTION__, udev->pm_usage_cnt);
+                       __func__, udev->pm_usage_cnt);
 }
 
 /**
@@ -1305,7 +1305,7 @@ int usb_autoresume_device(struct usb_device *udev)
 
        status = usb_autopm_do_device(udev, 1);
        dev_vdbg(&udev->dev, "%s: status %d cnt %d\n",
-                       __FUNCTION__, status, udev->pm_usage_cnt);
+                       __func__, status, udev->pm_usage_cnt);
        return status;
 }
 
@@ -1377,7 +1377,7 @@ void usb_autopm_put_interface(struct usb_interface *intf)
 
        status = usb_autopm_do_interface(intf, -1);
        dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
-                       __FUNCTION__, status, intf->pm_usage_cnt);
+                       __func__, status, intf->pm_usage_cnt);
 }
 EXPORT_SYMBOL_GPL(usb_autopm_put_interface);
 
@@ -1421,7 +1421,7 @@ int usb_autopm_get_interface(struct usb_interface *intf)
 
        status = usb_autopm_do_interface(intf, 1);
        dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
-                       __FUNCTION__, status, intf->pm_usage_cnt);
+                       __func__, status, intf->pm_usage_cnt);
        return status;
 }
 EXPORT_SYMBOL_GPL(usb_autopm_get_interface);
@@ -1443,7 +1443,7 @@ int usb_autopm_set_interface(struct usb_interface *intf)
 
        status = usb_autopm_do_interface(intf, 0);
        dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
-                       __FUNCTION__, status, intf->pm_usage_cnt);
+                       __func__, status, intf->pm_usage_cnt);
        return status;
 }
 EXPORT_SYMBOL_GPL(usb_autopm_set_interface);
index 5a338a5..06c3acb 100644 (file)
@@ -575,7 +575,7 @@ static int hub_hub_status(struct usb_hub *hub,
        ret = get_hub_status(hub->hdev, &hub->status->hub);
        if (ret < 0)
                dev_err (hub->intfdev,
-                       "%s failed (err = %d)\n", __FUNCTION__, ret);
+                       "%s failed (err = %d)\n", __func__, ret);
        else {
                *status = le16_to_cpu(hub->status->hub.wHubStatus);
                *change = le16_to_cpu(hub->status->hub.wHubChange); 
@@ -1270,7 +1270,7 @@ void usb_disconnect(struct usb_device **pdev)
        int                     i;
 
        if (!udev) {
-               pr_debug ("%s nodev\n", __FUNCTION__);
+               pr_debug ("%s nodev\n", __func__);
                return;
        }
 
@@ -2072,7 +2072,7 @@ static int hub_suspend(struct usb_interface *intf, pm_message_t msg)
                }
        }
 
-       dev_dbg(&intf->dev, "%s\n", __FUNCTION__);
+       dev_dbg(&intf->dev, "%s\n", __func__);
 
        /* stop khubd and related activity */
        hub_quiesce(hub);
@@ -3125,7 +3125,7 @@ int usb_reset_device(struct usb_device *udev)
 
        if (!parent_hdev) {
                /* this requires hcd-specific logic; see OHCI hc_restart() */
-               dev_dbg(&udev->dev, "%s for root hub!\n", __FUNCTION__);
+               dev_dbg(&udev->dev, "%s for root hub!\n", __func__);
                return -EISDIR;
        }
        parent_hub = hdev_to_hub(parent_hdev);
index 83a373e..8607846 100644 (file)
@@ -463,13 +463,13 @@ static int usbfs_fill_super(struct super_block *sb, void *data, int silent)
        inode = usbfs_get_inode(sb, S_IFDIR | 0755, 0);
 
        if (!inode) {
-               dbg("%s: could not get inode!",__FUNCTION__);
+               dbg("%s: could not get inode!",__func__);
                return -ENOMEM;
        }
 
        root = d_alloc_root(inode);
        if (!root) {
-               dbg("%s: could not get root dentry!",__FUNCTION__);
+               dbg("%s: could not get root dentry!",__func__);
                iput(inode);
                return -ENOMEM;
        }
index 5b23f6b..e819e53 100644 (file)
@@ -312,7 +312,7 @@ static void sg_complete(struct urb *urb)
                                    retval != -EBUSY)
                                        dev_err(&io->dev->dev,
                                                "%s, unlink --> %d\n",
-                                               __FUNCTION__, retval);
+                                               __func__, retval);
                        } else if (urb == io->urbs [i])
                                found = 1;
                }
@@ -550,7 +550,7 @@ void usb_sg_wait(struct usb_sg_request *io)
                        io->urbs[i]->dev = NULL;
                        io->urbs[i]->status = retval;
                        dev_dbg(&io->dev->dev, "%s, submit --> %d\n",
-                               __FUNCTION__, retval);
+                               __func__, retval);
                        usb_sg_cancel(io);
                }
                spin_lock_irq(&io->lock);
@@ -600,7 +600,7 @@ void usb_sg_cancel(struct usb_sg_request *io)
                        retval = usb_unlink_urb(io->urbs [i]);
                        if (retval != -EINPROGRESS && retval != -EBUSY)
                                dev_warn(&io->dev->dev, "%s, unlink --> %d\n",
-                                       __FUNCTION__, retval);
+                                       __func__, retval);
                }
                spin_lock(&io->lock);
        }
@@ -1068,7 +1068,7 @@ void usb_disable_device(struct usb_device *dev, int skip_ep0)
 {
        int i;
 
-       dev_dbg(&dev->dev, "%s nuking %s URBs\n", __FUNCTION__,
+       dev_dbg(&dev->dev, "%s nuking %s URBs\n", __func__,
                skip_ep0 ? "non-ep0" : "all");
        for (i = skip_ep0; i < 16; ++i) {
                usb_disable_endpoint(dev, i);
index 1d3ed13..c0b1ae2 100644 (file)
@@ -334,7 +334,7 @@ int usb_submit_urb(struct urb *urb, gfp_t mem_flags)
                dev_dbg(&dev->dev,
                        "bogus endpoint ep%d%s in %s (bad maxpacket %d)\n",
                        usb_endpoint_num(&ep->desc), is_out ? "out" : "in",
-                       __FUNCTION__, max);
+                       __func__, max);
                return -EMSGSIZE;
        }
 
index 5d352c9..9b913af 100644 (file)
@@ -460,7 +460,7 @@ static void nuke(struct at91_ep *ep, int status)
        if (list_empty(&ep->queue))
                return;
 
-       VDBG("%s %s\n", __FUNCTION__, ep->ep.name);
+       VDBG("%s %s\n", __func__, ep->ep.name);
        while (!list_empty(&ep->queue)) {
                req = list_entry(ep->queue.next, struct at91_request, queue);
                done(ep, req, status);
@@ -795,7 +795,7 @@ static int at91_wakeup(struct usb_gadget *gadget)
        int             status = -EINVAL;
        unsigned long   flags;
 
-       DBG("%s\n", __FUNCTION__ );
+       DBG("%s\n", __func__ );
        local_irq_save(flags);
 
        if (!udc->clocked || !udc->suspended)
index 74f51a7..6629310 100644 (file)
@@ -892,7 +892,7 @@ static int dummy_udc_suspend (struct platform_device *pdev, pm_message_t state)
 {
        struct dummy    *dum = platform_get_drvdata(pdev);
 
-       dev_dbg (&pdev->dev, "%s\n", __FUNCTION__);
+       dev_dbg (&pdev->dev, "%s\n", __func__);
        spin_lock_irq (&dum->lock);
        dum->udc_suspended = 1;
        set_link_state (dum);
@@ -906,7 +906,7 @@ static int dummy_udc_resume (struct platform_device *pdev)
 {
        struct dummy    *dum = platform_get_drvdata(pdev);
 
-       dev_dbg (&pdev->dev, "%s\n", __FUNCTION__);
+       dev_dbg (&pdev->dev, "%s\n", __func__);
        spin_lock_irq (&dum->lock);
        dum->udc_suspended = 0;
        set_link_state (dum);
@@ -1707,7 +1707,7 @@ static int dummy_bus_suspend (struct usb_hcd *hcd)
 {
        struct dummy *dum = hcd_to_dummy (hcd);
 
-       dev_dbg (&hcd->self.root_hub->dev, "%s\n", __FUNCTION__);
+       dev_dbg (&hcd->self.root_hub->dev, "%s\n", __func__);
 
        spin_lock_irq (&dum->lock);
        dum->rh_state = DUMMY_RH_SUSPENDED;
@@ -1722,7 +1722,7 @@ static int dummy_bus_resume (struct usb_hcd *hcd)
        struct dummy *dum = hcd_to_dummy (hcd);
        int rc = 0;
 
-       dev_dbg (&hcd->self.root_hub->dev, "%s\n", __FUNCTION__);
+       dev_dbg (&hcd->self.root_hub->dev, "%s\n", __func__);
 
        spin_lock_irq (&dum->lock);
        if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)) {
@@ -1896,7 +1896,7 @@ static int dummy_hcd_suspend (struct platform_device *pdev, pm_message_t state)
        struct dummy            *dum;
        int                     rc = 0;
 
-       dev_dbg (&pdev->dev, "%s\n", __FUNCTION__);
+       dev_dbg (&pdev->dev, "%s\n", __func__);
 
        hcd = platform_get_drvdata (pdev);
        dum = hcd_to_dummy (hcd);
@@ -1912,7 +1912,7 @@ static int dummy_hcd_resume (struct platform_device *pdev)
 {
        struct usb_hcd          *hcd;
 
-       dev_dbg (&pdev->dev, "%s\n", __FUNCTION__);
+       dev_dbg (&pdev->dev, "%s\n", __func__);
 
        hcd = platform_get_drvdata (pdev);
        set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
index 92b9bf7..bb93bdd 100644 (file)
@@ -1102,7 +1102,7 @@ static void eth_reset_config (struct eth_dev *dev)
        if (dev->config == 0)
                return;
 
-       DEBUG (dev, "%s\n", __FUNCTION__);
+       DEBUG (dev, "%s\n", __func__);
 
        netif_stop_queue (dev->net);
        netif_carrier_off (dev->net);
@@ -1263,7 +1263,7 @@ static void issue_start_status (struct eth_dev *dev)
        struct usb_cdc_notification     *event;
        int                             value;
 
-       DEBUG (dev, "%s, flush old status first\n", __FUNCTION__);
+       DEBUG (dev, "%s, flush old status first\n", __func__);
 
        /* flush old status
         *
@@ -1329,7 +1329,7 @@ static void rndis_command_complete (struct usb_ep *ep, struct usb_request *req)
        spin_lock(&dev->lock);
        status = rndis_msg_parser (dev->rndis_config, (u8 *) req->buf);
        if (status < 0)
-               ERROR(dev, "%s: rndis parse error %d\n", __FUNCTION__, status);
+               ERROR(dev, "%s: rndis parse error %d\n", __func__, status);
        spin_unlock(&dev->lock);
 }
 
@@ -2113,7 +2113,7 @@ static int rndis_control_ack (struct net_device *net)
 
 static void eth_start (struct eth_dev *dev, gfp_t gfp_flags)
 {
-       DEBUG (dev, "%s\n", __FUNCTION__);
+       DEBUG (dev, "%s\n", __func__);
 
        /* fill the rx queue */
        rx_fill (dev, gfp_flags);
@@ -2133,7 +2133,7 @@ static int eth_open (struct net_device *net)
 {
        struct eth_dev          *dev = netdev_priv(net);
 
-       DEBUG (dev, "%s\n", __FUNCTION__);
+       DEBUG (dev, "%s\n", __func__);
        if (netif_carrier_ok (dev->net))
                eth_start (dev, GFP_KERNEL);
        return 0;
@@ -2143,7 +2143,7 @@ static int eth_stop (struct net_device *net)
 {
        struct eth_dev          *dev = netdev_priv(net);
 
-       VDEBUG (dev, "%s\n", __FUNCTION__);
+       VDEBUG (dev, "%s\n", __func__);
        netif_stop_queue (net);
 
        DEBUG (dev, "stop stats: rx/tx %ld/%ld, errs %ld/%ld\n",
index 0a726e1..bf3f946 100644 (file)
@@ -1104,7 +1104,7 @@ static void ep0_complete(struct usb_ep *ep, struct usb_request *req)
        if (req->actual > 0)
                dump_msg(fsg, fsg->ep0req_name, req->buf, req->actual);
        if (req->status || req->actual != req->length)
-               DBG(fsg, "%s --> %d, %u/%u\n", __FUNCTION__,
+               DBG(fsg, "%s --> %d, %u/%u\n", __func__,
                                req->status, req->actual, req->length);
        if (req->status == -ECONNRESET)         // Request was cancelled
                usb_ep_fifo_flush(ep);
@@ -1125,7 +1125,7 @@ static void bulk_in_complete(struct usb_ep *ep, struct usb_request *req)
        struct fsg_buffhd       *bh = req->context;
 
        if (req->status || req->actual != req->length)
-               DBG(fsg, "%s --> %d, %u/%u\n", __FUNCTION__,
+               DBG(fsg, "%s --> %d, %u/%u\n", __func__,
                                req->status, req->actual, req->length);
        if (req->status == -ECONNRESET)         // Request was cancelled
                usb_ep_fifo_flush(ep);
@@ -1146,7 +1146,7 @@ static void bulk_out_complete(struct usb_ep *ep, struct usb_request *req)
 
        dump_msg(fsg, "bulk-out", req->buf, req->actual);
        if (req->status || req->actual != bh->bulk_out_intended_length)
-               DBG(fsg, "%s --> %d, %u/%u\n", __FUNCTION__,
+               DBG(fsg, "%s --> %d, %u/%u\n", __func__,
                                req->status, req->actual,
                                bh->bulk_out_intended_length);
        if (req->status == -ECONNRESET)         // Request was cancelled
@@ -1169,7 +1169,7 @@ static void intr_in_complete(struct usb_ep *ep, struct usb_request *req)
        struct fsg_buffhd       *bh = req->context;
 
        if (req->status || req->actual != req->length)
-               DBG(fsg, "%s --> %d, %u/%u\n", __FUNCTION__,
+               DBG(fsg, "%s --> %d, %u/%u\n", __func__,
                                req->status, req->actual, req->length);
        if (req->status == -ECONNRESET)         // Request was cancelled
                usb_ep_fifo_flush(ep);
index 254012a..651b827 100644 (file)
@@ -773,11 +773,11 @@ fsl_ep_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
        /* catch various bogus parameters */
        if (!_req || !req->req.complete || !req->req.buf
                        || !list_empty(&req->queue)) {
-               VDBG("%s, bad params\n", __FUNCTION__);
+               VDBG("%s, bad params\n", __func__);
                return -EINVAL;
        }
        if (unlikely(!_ep || !ep->desc)) {
-               VDBG("%s, bad ep\n", __FUNCTION__);
+               VDBG("%s, bad ep\n", __func__);
                return -EINVAL;
        }
        if (ep->desc->bmAttributes == USB_ENDPOINT_XFER_ISOC) {
index 9fb0b1e..98b1483 100644 (file)
@@ -512,7 +512,7 @@ struct fsl_udc {
 
 #ifdef DEBUG
 #define DBG(fmt, args...)      printk(KERN_DEBUG "[%s]  " fmt "\n", \
-                               __FUNCTION__, ## args)
+                               __func__, ## args)
 #else
 #define DBG(fmt, args...)      do{}while(0)
 #endif
index d3e7025..64a592c 100644 (file)
@@ -692,7 +692,7 @@ static void abort_dma(struct goku_ep *ep, int status)
        req->req.actual = (curr - req->req.dma) + 1;
        req->req.status = status;
 
-       VDBG(ep->dev, "%s %s %s %d/%d\n", __FUNCTION__, ep->ep.name,
+       VDBG(ep->dev, "%s %s %s %d/%d\n", __func__, ep->ep.name,
                ep->is_in ? "IN" : "OUT",
                req->req.actual, req->req.length);
 
@@ -826,7 +826,7 @@ static int goku_dequeue(struct usb_ep *_ep, struct usb_request *_req)
        if (dev->ep0state == EP0_SUSPEND)
                return -EBUSY;
 
-       VDBG(dev, "%s %s %s %s %p\n", __FUNCTION__, _ep->name,
+       VDBG(dev, "%s %s %s %s %p\n", __func__, _ep->name,
                ep->is_in ? "IN" : "OUT",
                ep->dma ? "dma" : "pio",
                _req);
@@ -898,7 +898,7 @@ static int goku_set_halt(struct usb_ep *_ep, int value)
 
        /* don't change EPxSTATUS_EP_INVALID to READY */
        } else if (!ep->desc) {
-               DBG(ep->dev, "%s %s inactive?\n", __FUNCTION__, ep->ep.name);
+               DBG(ep->dev, "%s %s inactive?\n", __func__, ep->ep.name);
                return -EINVAL;
        }
 
@@ -940,7 +940,7 @@ static int goku_fifo_status(struct usb_ep *_ep)
        regs = ep->dev->regs;
        size = readl(&regs->EPxSizeLA[ep->num]) & DATASIZE;
        size += readl(&regs->EPxSizeLB[ep->num]) & DATASIZE;
-       VDBG(ep->dev, "%s %s %u\n", __FUNCTION__, ep->ep.name, size);
+       VDBG(ep->dev, "%s %s %u\n", __func__, ep->ep.name, size);
        return size;
 }
 
@@ -953,11 +953,11 @@ static void goku_fifo_flush(struct usb_ep *_ep)
        if (!_ep)
                return;
        ep = container_of(_ep, struct goku_ep, ep);
-       VDBG(ep->dev, "%s %s\n", __FUNCTION__, ep->ep.name);
+       VDBG(ep->dev, "%s %s\n", __func__, ep->ep.name);
 
        /* don't change EPxSTATUS_EP_INVALID to READY */
        if (!ep->desc && ep->num != 0) {
-               DBG(ep->dev, "%s %s inactive?\n", __FUNCTION__, ep->ep.name);
+               DBG(ep->dev, "%s %s inactive?\n", __func__, ep->ep.name);
                return;
        }
 
@@ -1286,7 +1286,7 @@ static void ep0_start(struct goku_udc *dev)
        struct goku_udc_regs __iomem    *regs = dev->regs;
        unsigned                        i;
 
-       VDBG(dev, "%s\n", __FUNCTION__);
+       VDBG(dev, "%s\n", __func__);
 
        udc_reset(dev);
        udc_reinit (dev);
@@ -1322,7 +1322,7 @@ static void udc_enable(struct goku_udc *dev)
        if (readl(&dev->regs->power_detect) & PW_DETECT)
                ep0_start(dev);
        else {
-               DBG(dev, "%s\n", __FUNCTION__);
+               DBG(dev, "%s\n", __func__);
                dev->int_enable = INT_PWRDETECT;
                writel(dev->int_enable, &dev->regs->int_enable);
        }
@@ -1387,7 +1387,7 @@ stop_activity(struct goku_udc *dev, struct usb_gadget_driver *driver)
 {
        unsigned        i;
 
-       DBG (dev, "%s\n", __FUNCTION__);
+       DBG (dev, "%s\n", __func__);
 
        if (dev->gadget.speed == USB_SPEED_UNKNOWN)
                driver = NULL;
@@ -1726,7 +1726,7 @@ static void goku_remove(struct pci_dev *pdev)
 {
        struct goku_udc         *dev = pci_get_drvdata(pdev);
 
-       DBG(dev, "%s\n", __FUNCTION__);
+       DBG(dev, "%s\n", __func__);
 
        BUG_ON(dev->driver);
 
index 0a6feaf..69b0a27 100644 (file)
@@ -1107,13 +1107,13 @@ scan:
 
        switch (state) {
        default:
-               DBG (dev, "fail %s, state %d\n", __FUNCTION__, state);
+               DBG (dev, "fail %s, state %d\n", __func__, state);
                retval = -ESRCH;
                break;
        case STATE_DEV_UNCONNECTED:
        case STATE_DEV_CONNECTED:
                spin_unlock_irq (&dev->lock);
-               DBG (dev, "%s wait\n", __FUNCTION__);
+               DBG (dev, "%s wait\n", __func__);
 
                /* wait for events */
                retval = wait_event_interruptible (dev->wait,
@@ -1222,7 +1222,7 @@ ep0_write (struct file *fd, const char __user *buf, size_t len, loff_t *ptr)
                        DBG(dev, "bogus ep0out stall!\n");
                }
        } else
-               DBG (dev, "fail %s, state %d\n", __FUNCTION__, dev->state);
+               DBG (dev, "fail %s, state %d\n", __func__, dev->state);
 
        spin_unlock_irq (&dev->lock);
        return retval;
@@ -1233,7 +1233,7 @@ ep0_fasync (int f, struct file *fd, int on)
 {
        struct dev_data         *dev = fd->private_data;
        // caller must F_SETOWN before signal delivery happens
-       VDEBUG (dev, "%s %s\n", __FUNCTION__, on ? "on" : "off");
+       VDEBUG (dev, "%s %s\n", __func__, on ? "on" : "off");
        return fasync_helper (f, fd, on, &dev->fasync);
 }
 
@@ -1575,7 +1575,7 @@ static void destroy_ep_files (struct dev_data *dev)
 {
        struct list_head        *entry, *tmp;
 
-       DBG (dev, "%s %d\n", __FUNCTION__, dev->state);
+       DBG (dev, "%s %d\n", __func__, dev->state);
 
        /* dev->state must prevent interference */
 restart:
@@ -1662,7 +1662,7 @@ enomem1:
        put_dev (dev);
        kfree (data);
 enomem0:
-       DBG (dev, "%s enomem\n", __FUNCTION__);
+       DBG (dev, "%s enomem\n", __func__);
        destroy_ep_files (dev);
        return -ENOMEM;
 }
@@ -1672,7 +1672,7 @@ gadgetfs_unbind (struct usb_gadget *gadget)
 {
        struct dev_data         *dev = get_gadget_data (gadget);
 
-       DBG (dev, "%s\n", __FUNCTION__);
+       DBG (dev, "%s\n", __func__);
 
        spin_lock_irq (&dev->lock);
        dev->state = STATE_DEV_UNBOUND;
@@ -1685,7 +1685,7 @@ gadgetfs_unbind (struct usb_gadget *gadget)
        /* we've already been disconnected ... no i/o is active */
        if (dev->req)
                usb_ep_free_request (gadget->ep0, dev->req);
-       DBG (dev, "%s done\n", __FUNCTION__);
+       DBG (dev, "%s done\n", __func__);
        put_dev (dev);
 }
 
@@ -1933,7 +1933,7 @@ dev_config (struct file *fd, const char __user *buf, size_t len, loff_t *ptr)
 
 fail:
        spin_unlock_irq (&dev->lock);
-       pr_debug ("%s: %s fail %Zd, %p\n", shortname, __FUNCTION__, value, dev);
+       pr_debug ("%s: %s fail %Zd, %p\n", shortname, __func__, value, dev);
        kfree (dev->buf);
        dev->buf = NULL;
        return value;
index 078f724..825abd2 100644 (file)
@@ -253,7 +253,7 @@ udc_proc_read(char *page, char **start, off_t off, int count,
  */
 static void udc_disable(struct lh7a40x_udc *dev)
 {
-       DEBUG("%s, %p\n", __FUNCTION__, dev);
+       DEBUG("%s, %p\n", __func__, dev);
 
        udc_set_address(dev, 0);
 
@@ -285,7 +285,7 @@ static void udc_reinit(struct lh7a40x_udc *dev)
 {
        u32 i;
 
-       DEBUG("%s, %p\n", __FUNCTION__, dev);
+       DEBUG("%s, %p\n", __func__, dev);
 
        /* device/ep0 records init */
        INIT_LIST_HEAD(&dev->gadget.ep_list);
@@ -318,7 +318,7 @@ static void udc_enable(struct lh7a40x_udc *dev)
 {
        int ep;
 
-       DEBUG("%s, %p\n", __FUNCTION__, dev);
+       DEBUG("%s, %p\n", __func__, dev);
 
        dev->gadget.speed = USB_SPEED_UNKNOWN;
 
@@ -412,7 +412,7 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
        struct lh7a40x_udc *dev = the_controller;
        int retval;
 
-       DEBUG("%s: %s\n", __FUNCTION__, driver->driver.name);
+       DEBUG("%s: %s\n", __func__, driver->driver.name);
 
        if (!driver
                        || driver->speed != USB_SPEED_FULL
@@ -521,7 +521,7 @@ static int write_fifo(struct lh7a40x_ep *ep, struct lh7a40x_request *req)
                        is_short = unlikely(max < ep_maxpacket(ep));
                }
 
-               DEBUG("%s: wrote %s %d bytes%s%s %d left %p\n", __FUNCTION__,
+               DEBUG("%s: wrote %s %d bytes%s%s %d left %p\n", __func__,
                      ep->ep.name, count,
                      is_last ? "/L" : "", is_short ? "/S" : "",
                      req->req.length - req->req.actual, req);
@@ -555,7 +555,7 @@ static int read_fifo(struct lh7a40x_ep *ep, struct lh7a40x_request *req)
        /* make sure there's a packet in the FIFO. */
        csr = usb_read(ep->csr1);
        if (!(csr & USB_OUT_CSR1_OUT_PKT_RDY)) {
-               DEBUG("%s: Packet NOT ready!\n", __FUNCTION__);
+               DEBUG("%s: Packet NOT ready!\n", __func__);
                return -EINVAL;
        }
 
@@ -614,7 +614,7 @@ static void done(struct lh7a40x_ep *ep, struct lh7a40x_request *req, int status)
        unsigned int stopped = ep->stopped;
        u32 index;
 
-       DEBUG("%s, %p\n", __FUNCTION__, ep);
+       DEBUG("%s, %p\n", __func__, ep);
        list_del_init(&req->queue);
 
        if (likely(req->req.status == -EINPROGRESS))
@@ -644,7 +644,7 @@ static void done(struct lh7a40x_ep *ep, struct lh7a40x_request *req, int status)
 /** Enable EP interrupt */
 static void pio_irq_enable(int ep)
 {
-       DEBUG("%s: %d\n", __FUNCTION__, ep);
+       DEBUG("%s: %d\n", __func__, ep);
 
        switch (ep) {
        case 1:
@@ -665,7 +665,7 @@ static void pio_irq_enable(int ep)
 /** Disable EP interrupt */
 static void pio_irq_disable(int ep)
 {
-       DEBUG("%s: %d\n", __FUNCTION__, ep);
+       DEBUG("%s: %d\n", __func__, ep);
 
        switch (ep) {
        case 1:
@@ -690,7 +690,7 @@ void nuke(struct lh7a40x_ep *ep, int status)
 {
        struct lh7a40x_request *req;
 
-       DEBUG("%s, %p\n", __FUNCTION__, ep);
+       DEBUG("%s, %p\n", __func__, ep);
 
        /* Flush FIFO */
        flush(ep);
@@ -734,7 +734,7 @@ static void flush_all(struct lh7a40x_udc *dev)
  */
 static void flush(struct lh7a40x_ep *ep)
 {
-       DEBUG("%s, %p\n", __FUNCTION__, ep);
+       DEBUG("%s, %p\n", __func__, ep);
 
        switch (ep->ep_type) {
        case ep_control:
@@ -766,7 +766,7 @@ static void lh7a40x_in_epn(struct lh7a40x_udc *dev, u32 ep_idx, u32 intr)
        usb_set_index(ep_idx);
 
        csr = usb_read(ep->csr1);
-       DEBUG("%s: %d, csr %x\n", __FUNCTION__, ep_idx, csr);
+       DEBUG("%s: %d, csr %x\n", __func__, ep_idx, csr);
 
        if (csr & USB_IN_CSR1_SENT_STALL) {
                DEBUG("USB_IN_CSR1_SENT_STALL\n");
@@ -776,7 +776,7 @@ static void lh7a40x_in_epn(struct lh7a40x_udc *dev, u32 ep_idx, u32 intr)
        }
 
        if (!ep->desc) {
-               DEBUG("%s: NO EP DESC\n", __FUNCTION__);
+               DEBUG("%s: NO EP DESC\n", __func__);
                return;
        }
 
@@ -802,7 +802,7 @@ static void lh7a40x_out_epn(struct lh7a40x_udc *dev, u32 ep_idx, u32 intr)
        struct lh7a40x_ep *ep = &dev->ep[ep_idx];
        struct lh7a40x_request *req;
 
-       DEBUG("%s: %d\n", __FUNCTION__, ep_idx);
+       DEBUG("%s: %d\n", __func__, ep_idx);
 
        usb_set_index(ep_idx);
 
@@ -814,11 +814,11 @@ static void lh7a40x_out_epn(struct lh7a40x_udc *dev, u32 ep_idx, u32 intr)
                        usb_read(ep->
                                 csr1)) & (USB_OUT_CSR1_OUT_PKT_RDY |
                                           USB_OUT_CSR1_SENT_STALL)) {
-                       DEBUG("%s: %x\n", __FUNCTION__, csr);
+                       DEBUG("%s: %x\n", __func__, csr);
 
                        if (csr & USB_OUT_CSR1_SENT_STALL) {
                                DEBUG("%s: stall sent, flush fifo\n",
-                                     __FUNCTION__);
+                                     __func__);
                                /* usb_set(USB_OUT_CSR1_FIFO_FLUSH, ep->csr1); */
                                flush(ep);
                        } else if (csr & USB_OUT_CSR1_OUT_PKT_RDY) {
@@ -832,7 +832,7 @@ static void lh7a40x_out_epn(struct lh7a40x_udc *dev, u32 ep_idx, u32 intr)
 
                                if (!req) {
                                        printk("%s: NULL REQ %d\n",
-                                              __FUNCTION__, ep_idx);
+                                              __func__, ep_idx);
                                        flush(ep);
                                        break;
                                } else {
@@ -844,7 +844,7 @@ static void lh7a40x_out_epn(struct lh7a40x_udc *dev, u32 ep_idx, u32 intr)
 
        } else {
                /* Throw packet away.. */
-               printk("%s: No descriptor?!?\n", __FUNCTION__);
+               printk("%s: No descriptor?!?\n", __func__);
                flush(ep);
        }
 }
@@ -886,7 +886,7 @@ static void lh7a40x_reset_intr(struct lh7a40x_udc *dev)
 #if 0                          /* def CONFIG_ARCH_LH7A404 */
        /* Does not work always... */
 
-       DEBUG("%s: %d\n", __FUNCTION__, dev->usb_address);
+       DEBUG("%s: %d\n", __func__, dev->usb_address);
 
        if (!dev->usb_address) {
                /*usb_set(USB_RESET_IO, USB_RESET);
@@ -936,7 +936,7 @@ static irqreturn_t lh7a40x_udc_irq(int irq, void *_dev)
                if (!intr_out && !intr_in && !intr_int)
                        break;
 
-               DEBUG("%s (on state %s)\n", __FUNCTION__,
+               DEBUG("%s (on state %s)\n", __func__,
                      state_names[dev->ep0state]);
                DEBUG("intr_out = %x\n", intr_out);
                DEBUG("intr_in  = %x\n", intr_in);
@@ -1016,14 +1016,14 @@ static int lh7a40x_ep_enable(struct usb_ep *_ep,
        struct lh7a40x_udc *dev;
        unsigned long flags;
 
-       DEBUG("%s, %p\n", __FUNCTION__, _ep);
+       DEBUG("%s, %p\n", __func__, _ep);
 
        ep = container_of(_ep, struct lh7a40x_ep, ep);
        if (!_ep || !desc || ep->desc || _ep->name == ep0name
            || desc->bDescriptorType != USB_DT_ENDPOINT
            || ep->bEndpointAddress != desc->bEndpointAddress
            || ep_maxpacket(ep) < le16_to_cpu(desc->wMaxPacketSize)) {
-               DEBUG("%s, bad ep or descriptor\n", __FUNCTION__);
+               DEBUG("%s, bad ep or descriptor\n", __func__);
                return -EINVAL;
        }
 
@@ -1031,7 +1031,7 @@ static int lh7a40x_ep_enable(struct usb_ep *_ep,
        if (ep->bmAttributes != desc->bmAttributes
            && ep->bmAttributes != USB_ENDPOINT_XFER_BULK
            && desc->bmAttributes != USB_ENDPOINT_XFER_INT) {
-               DEBUG("%s, %s type mismatch\n", __FUNCTION__, _ep->name);
+               DEBUG("%s, %s type mismatch\n", __func__, _ep->name);
                return -EINVAL;
        }
 
@@ -1039,13 +1039,13 @@ static int lh7a40x_ep_enable(struct usb_ep *_ep,
        if ((desc->bmAttributes == USB_ENDPOINT_XFER_BULK
             && le16_to_cpu(desc->wMaxPacketSize) != ep_maxpacket(ep))
            || !desc->wMaxPacketSize) {
-               DEBUG("%s, bad %s maxpacket\n", __FUNCTION__, _ep->name);
+               DEBUG("%s, bad %s maxpacket\n", __func__, _ep->name);
                return -ERANGE;
        }
 
        dev = ep->dev;
        if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN) {
-               DEBUG("%s, bogus device state\n", __FUNCTION__);
+               DEBUG("%s, bogus device state\n", __func__);
                return -ESHUTDOWN;
        }
 
@@ -1061,7 +1061,7 @@ static int lh7a40x_ep_enable(struct usb_ep *_ep,
        /* Reset halt state (does flush) */
        lh7a40x_set_halt(_ep, 0);
 
-       DEBUG("%s: enabled %s\n", __FUNCTION__, _ep->name);
+       DEBUG("%s: enabled %s\n", __func__, _ep->name);
        return 0;
 }
 
@@ -1073,11 +1073,11 @@ static int lh7a40x_ep_disable(struct usb_ep *_ep)
        struct lh7a40x_ep *ep;
        unsigned long flags;
 
-       DEBUG("%s, %p\n", __FUNCTION__, _ep);
+       DEBUG("%s, %p\n", __func__, _ep);
 
        ep = container_of(_ep, struct lh7a40x_ep, ep);
        if (!_ep || !ep->desc) {
-               DEBUG("%s, %s not enabled\n", __FUNCTION__,
+               DEBUG("%s, %s not enabled\n", __func__,
                      _ep ? ep->ep.name : NULL);
                return -EINVAL;
        }
@@ -1097,7 +1097,7 @@ static int lh7a40x_ep_disable(struct usb_ep *_ep)
 
        spin_unlock_irqrestore(&ep->dev->lock, flags);
 
-       DEBUG("%s: disabled %s\n", __FUNCTION__, _ep->name);
+       DEBUG("%s: disabled %s\n", __func__, _ep->name);
        return 0;
 }
 
@@ -1106,7 +1106,7 @@ static struct usb_request *lh7a40x_alloc_request(struct usb_ep *ep,
 {
        struct lh7a40x_request *req;
 
-       DEBUG("%s, %p\n", __FUNCTION__, ep);
+       DEBUG("%s, %p\n", __func__, ep);
 
        req = kzalloc(sizeof(*req), gfp_flags);
        if (!req)
@@ -1121,7 +1121,7 @@ static void lh7a40x_free_request(struct usb_ep *ep, struct usb_request *_req)
 {
        struct lh7a40x_request *req;
 
-       DEBUG("%s, %p\n", __FUNCTION__, ep);
+       DEBUG("%s, %p\n", __func__, ep);
 
        req = container_of(_req, struct lh7a40x_request, req);
        WARN_ON(!list_empty(&req->queue));
@@ -1140,25 +1140,25 @@ static int lh7a40x_queue(struct usb_ep *_ep, struct usb_request *_req,
        struct lh7a40x_udc *dev;
        unsigned long flags;
 
-       DEBUG("\n\n\n%s, %p\n", __FUNCTION__, _ep);
+       DEBUG("\n\n\n%s, %p\n", __func__, _ep);
 
        req = container_of(_req, struct lh7a40x_request, req);
        if (unlikely
            (!_req || !_req->complete || !_req->buf
             || !list_empty(&req->queue))) {
-               DEBUG("%s, bad params\n", __FUNCTION__);
+               DEBUG("%s, bad params\n", __func__);
                return -EINVAL;
        }
 
        ep = container_of(_ep, struct lh7a40x_ep, ep);
        if (unlikely(!_ep || (!ep->desc && ep->ep.name != ep0name))) {
-               DEBUG("%s, bad ep\n", __FUNCTION__);
+               DEBUG("%s, bad ep\n", __func__);
                return -EINVAL;
        }
 
        dev = ep->dev;
        if (unlikely(!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)) {
-               DEBUG("%s, bogus device state %p\n", __FUNCTION__, dev->driver);
+               DEBUG("%s, bogus device state %p\n", __func__, dev->driver);
                return -ESHUTDOWN;
        }
 
@@ -1218,7 +1218,7 @@ static int lh7a40x_dequeue(struct usb_ep *_ep, struct usb_request *_req)
        struct lh7a40x_request *req;
        unsigned long flags;
 
-       DEBUG("%s, %p\n", __FUNCTION__, _ep);
+       DEBUG("%s, %p\n", __func__, _ep);
 
        ep = container_of(_ep, struct lh7a40x_ep, ep);
        if (!_ep || ep->ep.name == ep0name)
@@ -1253,13 +1253,13 @@ static int lh7a40x_set_halt(struct usb_ep *_ep, int value)
 
        ep = container_of(_ep, struct lh7a40x_ep, ep);
        if (unlikely(!_ep || (!ep->desc && ep->ep.name != ep0name))) {
-               DEBUG("%s, bad ep\n", __FUNCTION__);
+               DEBUG("%s, bad ep\n", __func__);
                return -EINVAL;
        }
 
        usb_set_index(ep_index(ep));
 
-       DEBUG("%s, ep %d, val %d\n", __FUNCTION__, ep_index(ep), value);
+       DEBUG("%s, ep %d, val %d\n", __func__, ep_index(ep), value);
 
        spin_lock_irqsave(&ep->dev->lock, flags);
 
@@ -1325,11 +1325,11 @@ static int lh7a40x_fifo_status(struct usb_ep *_ep)
 
        ep = container_of(_ep, struct lh7a40x_ep, ep);
        if (!_ep) {
-               DEBUG("%s, bad ep\n", __FUNCTION__);
+               DEBUG("%s, bad ep\n", __func__);
                return -ENODEV;
        }
 
-       DEBUG("%s, %d\n", __FUNCTION__, ep_index(ep));
+       DEBUG("%s, %d\n", __func__, ep_index(ep));
 
        /* LPD can't report unclaimed bytes from IN fifos */
        if (ep_is_in(ep))
@@ -1355,7 +1355,7 @@ static void lh7a40x_fifo_flush(struct usb_ep *_ep)
 
        ep = container_of(_ep, struct lh7a40x_ep, ep);
        if (unlikely(!_ep || (!ep->desc && ep->ep.name != ep0name))) {
-               DEBUG("%s, bad ep\n", __FUNCTION__);
+               DEBUG("%s, bad ep\n", __func__);
                return;
        }
 
@@ -1376,7 +1376,7 @@ static int write_fifo_ep0(struct lh7a40x_ep *ep, struct lh7a40x_request *req)
 
        max = ep_maxpacket(ep);
 
-       DEBUG_EP0("%s\n", __FUNCTION__);
+       DEBUG_EP0("%s\n", __func__);
 
        count = write_packet(ep, req, max);
 
@@ -1390,7 +1390,7 @@ static int write_fifo_ep0(struct lh7a40x_ep *ep, struct lh7a40x_request *req)
                        is_last = 1;
        }
 
-       DEBUG_EP0("%s: wrote %s %d bytes%s %d left %p\n", __FUNCTION__,
+       DEBUG_EP0("%s: wrote %s %d bytes%s %d left %p\n", __func__,
                  ep->ep.name, count,
                  is_last ? "/L" : "", req->req.length - req->req.actual, req);
 
@@ -1434,7 +1434,7 @@ static int read_fifo_ep0(struct lh7a40x_ep *ep, struct lh7a40x_request *req)
        unsigned bufferspace, count, is_short;
        volatile u32 *fifo = (volatile u32 *)ep->fifo;
 
-       DEBUG_EP0("%s\n", __FUNCTION__);
+       DEBUG_EP0("%s\n", __func__);
 
        csr = usb_read(USB_EP0_CSR);
        if (!(csr & USB_OUT_CSR1_OUT_PKT_RDY))
@@ -1492,7 +1492,7 @@ static int read_fifo_ep0(struct lh7a40x_ep *ep, struct lh7a40x_request *req)
  */
 static void udc_set_address(struct lh7a40x_udc *dev, unsigned char address)
 {
-       DEBUG_EP0("%s: %d\n", __FUNCTION__, address);
+       DEBUG_EP0("%s: %d\n", __func__, address);
        /* c.f. 15.1.2.2 Table 15-4 address will be used after DATA_END is set */
        dev->usb_address = address;
        usb_set((address & USB_FA_FUNCTION_ADDR), USB_FA);
@@ -1514,7 +1514,7 @@ static void lh7a40x_ep0_out(struct lh7a40x_udc *dev, u32 csr)
        struct lh7a40x_ep *ep = &dev->ep[0];
        int ret;
 
-       DEBUG_EP0("%s: %x\n", __FUNCTION__, csr);
+       DEBUG_EP0("%s: %x\n", __func__, csr);
 
        if (list_empty(&ep->queue))
                req = 0;
@@ -1533,13 +1533,13 @@ static void lh7a40x_ep0_out(struct lh7a40x_udc *dev, u32 csr)
                if (ret) {
                        /* Done! */
                        DEBUG_EP0("%s: finished, waiting for status\n",
-                                 __FUNCTION__);
+                                 __func__);
 
                        usb_set((EP0_CLR_OUT | EP0_DATA_END), USB_EP0_CSR);
                        dev->ep0state = WAIT_FOR_SETUP;
                } else {
                        /* Not done yet.. */
-                       DEBUG_EP0("%s: not finished\n", __FUNCTION__);
+                       DEBUG_EP0("%s: not finished\n", __func__);
                        usb_set(EP0_CLR_OUT, USB_EP0_CSR);
                }
        } else {
@@ -1556,7 +1556,7 @@ static int lh7a40x_ep0_in(struct lh7a40x_udc *dev, u32 csr)
        struct lh7a40x_ep *ep = &dev->ep[0];
        int ret, need_zlp = 0;
 
-       DEBUG_EP0("%s: %x\n", __FUNCTION__, csr);
+       DEBUG_EP0("%s: %x\n", __func__, csr);
 
        if (list_empty(&ep->queue))
                req = 0;
@@ -1564,7 +1564,7 @@ static int lh7a40x_ep0_in(struct lh7a40x_udc *dev, u32 csr)
                req = list_entry(ep->queue.next, struct lh7a40x_request, queue);
 
        if (!req) {
-               DEBUG_EP0("%s: NULL REQ\n", __FUNCTION__);
+               DEBUG_EP0("%s: NULL REQ\n", __func__);
                return 0;
        }
 
@@ -1585,17 +1585,17 @@ static int lh7a40x_ep0_in(struct lh7a40x_udc *dev, u32 csr)
 
        if (ret == 1 && !need_zlp) {
                /* Last packet */
-               DEBUG_EP0("%s: finished, waiting for status\n", __FUNCTION__);
+               DEBUG_EP0("%s: finished, waiting for status\n", __func__);
 
                usb_set((EP0_IN_PKT_RDY | EP0_DATA_END), USB_EP0_CSR);
                dev->ep0state = WAIT_FOR_SETUP;
        } else {
-               DEBUG_EP0("%s: not finished\n", __FUNCTION__);
+               DEBUG_EP0("%s: not finished\n", __func__);
                usb_set(EP0_IN_PKT_RDY, USB_EP0_CSR);
        }
 
        if (need_zlp) {
-               DEBUG_EP0("%s: Need ZLP!\n", __FUNCTION__);
+               DEBUG_EP0("%s: Need ZLP!\n", __func__);
                usb_set(EP0_IN_PKT_RDY, USB_EP0_CSR);
                dev->ep0state = DATA_STATE_NEED_ZLP;
        }
@@ -1694,7 +1694,7 @@ static void lh7a40x_ep0_setup(struct lh7a40x_udc *dev, u32 csr)
        struct usb_ctrlrequest ctrl;
        int i, bytes, is_in;
 
-       DEBUG_SETUP("%s: %x\n", __FUNCTION__, csr);
+       DEBUG_SETUP("%s: %x\n", __func__, csr);
 
        /* Nuke all previous transfers */
        nuke(ep, -EPROTO);
@@ -1799,7 +1799,7 @@ static void lh7a40x_ep0_setup(struct lh7a40x_udc *dev, u32 csr)
  */
 static void lh7a40x_ep0_in_zlp(struct lh7a40x_udc *dev, u32 csr)
 {
-       DEBUG_EP0("%s: %x\n", __FUNCTION__, csr);
+       DEBUG_EP0("%s: %x\n", __func__, csr);
 
        /* c.f. Table 15-14 */
        usb_set((EP0_IN_PKT_RDY | EP0_DATA_END), USB_EP0_CSR);
@@ -1818,7 +1818,7 @@ static void lh7a40x_handle_ep0(struct lh7a40x_udc *dev, u32 intr)
        usb_set_index(0);
        csr = usb_read(USB_EP0_CSR);
 
-       DEBUG_EP0("%s: csr = %x\n", __FUNCTION__, csr);
+       DEBUG_EP0("%s: csr = %x\n", __func__, csr);
 
        /*
         * For overview of what we should be doing see c.f. Chapter 18.1.2.4
@@ -1832,7 +1832,7 @@ static void lh7a40x_handle_ep0(struct lh7a40x_udc *dev, u32 intr)
         *      - clear the SENT_STALL bit
         */
        if (csr & EP0_SENT_STALL) {
-               DEBUG_EP0("%s: EP0_SENT_STALL is set: %x\n", __FUNCTION__, csr);
+               DEBUG_EP0("%s: EP0_SENT_STALL is set: %x\n", __func__, csr);
                usb_clear((EP0_SENT_STALL | EP0_SEND_STALL), USB_EP0_CSR);
                nuke(ep, -ECONNABORTED);
                dev->ep0state = WAIT_FOR_SETUP;
@@ -1849,7 +1849,7 @@ static void lh7a40x_handle_ep0(struct lh7a40x_udc *dev, u32 intr)
         */
        if (!(csr & (EP0_IN_PKT_RDY | EP0_OUT_PKT_RDY))) {
                DEBUG_EP0("%s: IN_PKT_RDY and OUT_PKT_RDY are clear\n",
-                         __FUNCTION__);
+                         __func__);
 
                switch (dev->ep0state) {
                case DATA_STATE_XMIT:
@@ -1877,7 +1877,7 @@ static void lh7a40x_handle_ep0(struct lh7a40x_udc *dev, u32 intr)
         *      - set SERVICED_SETUP_END_BIT
         */
        if (csr & EP0_SETUP_END) {
-               DEBUG_EP0("%s: EP0_SETUP_END is set: %x\n", __FUNCTION__, csr);
+               DEBUG_EP0("%s: EP0_SETUP_END is set: %x\n", __func__, csr);
 
                usb_set(EP0_CLR_SETUP_END, USB_EP0_CSR);
 
@@ -1896,7 +1896,7 @@ static void lh7a40x_handle_ep0(struct lh7a40x_udc *dev, u32 intr)
         */
        if (csr & EP0_OUT_PKT_RDY) {
 
-               DEBUG_EP0("%s: EP0_OUT_PKT_RDY is set: %x\n", __FUNCTION__,
+               DEBUG_EP0("%s: EP0_OUT_PKT_RDY is set: %x\n", __func__,
                          csr);
 
                switch (dev->ep0state) {
@@ -1926,7 +1926,7 @@ static void lh7a40x_ep0_kick(struct lh7a40x_udc *dev, struct lh7a40x_ep *ep)
        usb_set_index(0);
        csr = usb_read(USB_EP0_CSR);
 
-       DEBUG_EP0("%s: %x\n", __FUNCTION__, csr);
+       DEBUG_EP0("%s: %x\n", __func__, csr);
 
        /* Clear "out packet ready" */
        usb_set(EP0_CLR_OUT, USB_EP0_CSR);
@@ -1949,7 +1949,7 @@ static int lh7a40x_udc_get_frame(struct usb_gadget *_gadget)
 {
        u32 frame1 = usb_read(USB_FRM_NUM1);    /* Least significant 8 bits */
        u32 frame2 = usb_read(USB_FRM_NUM2);    /* Most significant 3 bits */
-       DEBUG("%s, %p\n", __FUNCTION__, _gadget);
+       DEBUG("%s, %p\n", __func__, _gadget);
        return ((frame2 & 0x07) << 8) | (frame1 & 0xff);
 }
 
@@ -1970,7 +1970,7 @@ static const struct usb_gadget_ops lh7a40x_udc_ops = {
 
 static void nop_release(struct device *dev)
 {
-       DEBUG("%s %s\n", __FUNCTION__, dev->bus_id);
+       DEBUG("%s %s\n", __func__, dev->bus_id);
 }
 
 static struct lh7a40x_udc memory = {
@@ -2065,7 +2065,7 @@ static int lh7a40x_udc_probe(struct platform_device *pdev)
        struct lh7a40x_udc *dev = &memory;
        int retval;
 
-       DEBUG("%s: %p\n", __FUNCTION__, pdev);
+       DEBUG("%s: %p\n", __func__, pdev);
 
        spin_lock_init(&dev->lock);
        dev->dev = &pdev->dev;
@@ -2098,7 +2098,7 @@ static int lh7a40x_udc_remove(struct platform_device *pdev)
 {
        struct lh7a40x_udc *dev = platform_get_drvdata(pdev);
 
-       DEBUG("%s: %p\n", __FUNCTION__, pdev);
+       DEBUG("%s: %p\n", __func__, pdev);
 
        if (dev->driver)
                return -EBUSY;
@@ -2131,7 +2131,7 @@ static struct platform_driver udc_driver = {
 
 static int __init udc_init(void)
 {
-       DEBUG("%s: %s version %s\n", __FUNCTION__, driver_name, DRIVER_VERSION);
+       DEBUG("%s: %s version %s\n", __func__, driver_name, DRIVER_VERSION);
        return platform_driver_register(&udc_driver);
 }
 
index 44ca139..1f2af39 100644 (file)
@@ -299,7 +299,7 @@ static inline void assert_out_naking (struct net2280_ep *ep, const char *where)
                        &ep->regs->ep_rsp);
        }
 }
-#define ASSERT_OUT_NAKING(ep) assert_out_naking(ep,__FUNCTION__)
+#define ASSERT_OUT_NAKING(ep) assert_out_naking(ep,__func__)
 #else
 #define ASSERT_OUT_NAKING(ep) do {} while (0)
 #endif
index 56277d2..95f7662 100644 (file)
@@ -163,7 +163,7 @@ static int omap_ep_enable(struct usb_ep *_ep,
                        || ep->bEndpointAddress != desc->bEndpointAddress
                        || ep->maxpacket < le16_to_cpu
                                                (desc->wMaxPacketSize)) {
-               DBG("%s, bad ep or descriptor\n", __FUNCTION__);
+               DBG("%s, bad ep or descriptor\n", __func__);
                return -EINVAL;
        }
        maxp = le16_to_cpu (desc->wMaxPacketSize);
@@ -171,7 +171,7 @@ static int omap_ep_enable(struct usb_ep *_ep,
                                && maxp != ep->maxpacket)
                        || le16_to_cpu(desc->wMaxPacketSize) > ep->maxpacket
                        || !desc->wMaxPacketSize) {
-               DBG("%s, bad %s maxpacket\n", __FUNCTION__, _ep->name);
+               DBG("%s, bad %s maxpacket\n", __func__, _ep->name);
                return -ERANGE;
        }
 
@@ -194,13 +194,13 @@ static int omap_ep_enable(struct usb_ep *_ep,
        if (ep->bmAttributes != desc->bmAttributes
                        && ep->bmAttributes != USB_ENDPOINT_XFER_BULK
                        && desc->bmAttributes != USB_ENDPOINT_XFER_INT) {
-               DBG("%s, %s type mismatch\n", __FUNCTION__, _ep->name);
+               DBG("%s, %s type mismatch\n", __func__, _ep->name);
                return -EINVAL;
        }
 
        udc = ep->udc;
        if (!udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN) {
-               DBG("%s, bogus device state\n", __FUNCTION__);
+               DBG("%s, bogus device state\n", __func__);
                return -ESHUTDOWN;
        }
 
@@ -249,7 +249,7 @@ static int omap_ep_disable(struct usb_ep *_ep)
        unsigned long   flags;
 
        if (!_ep || !ep->desc) {
-               DBG("%s, %s not enabled\n", __FUNCTION__,
+               DBG("%s, %s not enabled\n", __func__,
                        _ep ? ep->ep.name : NULL);
                return -EINVAL;
        }
@@ -936,11 +936,11 @@ omap_ep_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
        /* catch various bogus parameters */
        if (!_req || !req->req.complete || !req->req.buf
                        || !list_empty(&req->queue)) {
-               DBG("%s, bad params\n", __FUNCTION__);
+               DBG("%s, bad params\n", __func__);
                return -EINVAL;
        }
        if (!_ep || (!ep->desc && ep->bEndpointAddress)) {
-               DBG("%s, bad ep\n", __FUNCTION__);
+               DBG("%s, bad ep\n", __func__);
                return -EINVAL;
        }
        if (ep->bmAttributes == USB_ENDPOINT_XFER_ISOC) {
@@ -959,7 +959,7 @@ omap_ep_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
                        && (ep->bEndpointAddress & USB_DIR_IN) == 0
                        && !cpu_class_is_omap2()
                        && (req->req.length % ep->ep.maxpacket) != 0) {
-               DBG("%s, no partial packet OUT reads\n", __FUNCTION__);
+               DBG("%s, no partial packet OUT reads\n", __func__);
                return -EMSGSIZE;
        }
 
index ecc1410..76be75e 100644 (file)
@@ -915,7 +915,7 @@ static void printer_reset_interface(struct printer_dev *dev)
        if (dev->interface < 0)
                return;
 
-       DBG(dev, "%s\n", __FUNCTION__);
+       DBG(dev, "%s\n", __func__);
 
        if (dev->in)
                usb_ep_disable(dev->in_ep);
@@ -1284,7 +1284,7 @@ printer_disconnect(struct usb_gadget *gadget)
        struct printer_dev      *dev = get_gadget_data(gadget);
        unsigned long           flags;
 
-       DBG(dev, "%s\n", __FUNCTION__);
+       DBG(dev, "%s\n", __func__);
 
        spin_lock_irqsave(&dev->lock, flags);
 
@@ -1300,7 +1300,7 @@ printer_unbind(struct usb_gadget *gadget)
        struct usb_request      *req;
 
 
-       DBG(dev, "%s\n", __FUNCTION__);
+       DBG(dev, "%s\n", __func__);
 
        /* Remove sysfs files */
        device_destroy(usb_gadget_class, g_printer_devno);
index c00cd8b..08f699b 100644 (file)
@@ -235,7 +235,7 @@ static int pxa2xx_ep_enable (struct usb_ep *_ep,
                        || ep->bEndpointAddress != desc->bEndpointAddress
                        || ep->fifo_size < le16_to_cpu
                                                (desc->wMaxPacketSize)) {
-               DMSG("%s, bad ep or descriptor\n", __FUNCTION__);
+               DMSG("%s, bad ep or descriptor\n", __func__);
                return -EINVAL;
        }
 
@@ -243,7 +243,7 @@ static int pxa2xx_ep_enable (struct usb_ep *_ep,
        if (ep->bmAttributes != desc->bmAttributes
                        && ep->bmAttributes != USB_ENDPOINT_XFER_BULK
                        && desc->bmAttributes != USB_ENDPOINT_XFER_INT) {
-               DMSG("%s, %s type mismatch\n", __FUNCTION__, _ep->name);
+               DMSG("%s, %s type mismatch\n", __func__, _ep->name);
                return -EINVAL;
        }
 
@@ -252,13 +252,13 @@ static int pxa2xx_ep_enable (struct usb_ep *_ep,
                                && le16_to_cpu (desc->wMaxPacketSize)
                                                != BULK_FIFO_SIZE)
                        || !desc->wMaxPacketSize) {
-               DMSG("%s, bad %s maxpacket\n", __FUNCTION__, _ep->name);
+               DMSG("%s, bad %s maxpacket\n", __func__, _ep->name);
                return -ERANGE;
        }
 
        dev = ep->dev;
        if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN) {
-               DMSG("%s, bogus device state\n", __FUNCTION__);
+               DMSG("%s, bogus device state\n", __func__);
                return -ESHUTDOWN;
        }
 
@@ -283,7 +283,7 @@ static int pxa2xx_ep_disable (struct usb_ep *_ep)
 
        ep = container_of (_ep, struct pxa2xx_ep, ep);
        if (!_ep || !ep->desc) {
-               DMSG("%s, %s not enabled\n", __FUNCTION__,
+               DMSG("%s, %s not enabled\n", __func__,
                        _ep ? ep->ep.name : NULL);
                return -EINVAL;
        }
@@ -461,7 +461,7 @@ void ep0start(struct pxa2xx_udc *dev, u32 flags, const char *tag)
        USIR0 = USIR0_IR0;
        dev->req_pending = 0;
        DBG(DBG_VERY_NOISY, "%s %s, %02x/%02x\n",
-               __FUNCTION__, tag, UDCCS0, flags);
+               __func__, tag, UDCCS0, flags);
 }
 
 static int
@@ -651,20 +651,20 @@ pxa2xx_ep_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
        req = container_of(_req, struct pxa2xx_request, req);
        if (unlikely (!_req || !_req->complete || !_req->buf
                        || !list_empty(&req->queue))) {
-               DMSG("%s, bad params\n", __FUNCTION__);
+               DMSG("%s, bad params\n", __func__);
                return -EINVAL;
        }
 
        ep = container_of(_ep, struct pxa2xx_ep, ep);
        if (unlikely (!_ep || (!ep->desc && ep->ep.name != ep0name))) {
-               DMSG("%s, bad ep\n", __FUNCTION__);
+               DMSG("%s, bad ep\n", __func__);
                return -EINVAL;
        }
 
        dev = ep->dev;
        if (unlikely (!dev->driver
                        || dev->gadget.speed == USB_SPEED_UNKNOWN)) {
-               DMSG("%s, bogus device state\n", __FUNCTION__);
+               DMSG("%s, bogus device state\n", __func__);
                return -ESHUTDOWN;
        }
 
@@ -807,7 +807,7 @@ static int pxa2xx_ep_set_halt(struct usb_ep *_ep, int value)
        if (unlikely (!_ep
                        || (!ep->desc && ep->ep.name != ep0name))
                        || ep->bmAttributes == USB_ENDPOINT_XFER_ISOC) {
-               DMSG("%s, bad ep\n", __FUNCTION__);
+               DMSG("%s, bad ep\n", __func__);
                return -EINVAL;
        }
        if (value == 0) {
@@ -859,7 +859,7 @@ static int pxa2xx_ep_fifo_status(struct usb_ep *_ep)
 
        ep = container_of(_ep, struct pxa2xx_ep, ep);
        if (!_ep) {
-               DMSG("%s, bad ep\n", __FUNCTION__);
+               DMSG("%s, bad ep\n", __func__);
                return -ENODEV;
        }
        /* pxa can't report unclaimed bytes from IN fifos */
@@ -878,7 +878,7 @@ static void pxa2xx_ep_fifo_flush(struct usb_ep *_ep)
 
        ep = container_of(_ep, struct pxa2xx_ep, ep);
        if (!_ep || ep->ep.name == ep0name || !list_empty(&ep->queue)) {
-               DMSG("%s, bad ep\n", __FUNCTION__);
+               DMSG("%s, bad ep\n", __func__);
                return;
        }
 
@@ -1813,7 +1813,7 @@ pxa2xx_udc_irq(int irq, void *_dev)
 
 static void nop_release (struct device *dev)
 {
-       DMSG("%s %s\n", __FUNCTION__, dev->bus_id);
+       DMSG("%s %s\n", __func__, dev->bus_id);
 }
 
 /* this uses load-time allocation and initialization (instead of
index 934911e..bd58dd5 100644 (file)
@@ -204,7 +204,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
 
        /* mandatory */
        case OID_GEN_SUPPORTED_LIST:
-               DBG("%s: OID_GEN_SUPPORTED_LIST\n", __FUNCTION__);
+               DBG("%s: OID_GEN_SUPPORTED_LIST\n", __func__);
                length = sizeof (oid_supported_list);
                count  = length / sizeof (u32);
                for (i = 0; i < count; i++)
@@ -214,7 +214,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
 
        /* mandatory */
        case OID_GEN_HARDWARE_STATUS:
-               DBG("%s: OID_GEN_HARDWARE_STATUS\n", __FUNCTION__);
+               DBG("%s: OID_GEN_HARDWARE_STATUS\n", __func__);
                /* Bogus question!
                 * Hardware must be ready to receive high level protocols.
                 * BTW:
@@ -227,14 +227,14 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
 
        /* mandatory */
        case OID_GEN_MEDIA_SUPPORTED:
-               DBG("%s: OID_GEN_MEDIA_SUPPORTED\n", __FUNCTION__);
+               DBG("%s: OID_GEN_MEDIA_SUPPORTED\n", __func__);
                *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr].medium);
                retval = 0;
                break;
 
        /* mandatory */
        case OID_GEN_MEDIA_IN_USE:
-               DBG("%s: OID_GEN_MEDIA_IN_USE\n", __FUNCTION__);
+               DBG("%s: OID_GEN_MEDIA_IN_USE\n", __func__);
                /* one medium, one transport... (maybe you do it better) */
                *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr].medium);
                retval = 0;
@@ -242,7 +242,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
 
        /* mandatory */
        case OID_GEN_MAXIMUM_FRAME_SIZE:
-               DBG("%s: OID_GEN_MAXIMUM_FRAME_SIZE\n", __FUNCTION__);
+               DBG("%s: OID_GEN_MAXIMUM_FRAME_SIZE\n", __func__);
                if (rndis_per_dev_params [configNr].dev) {
                        *outbuf = cpu_to_le32 (
                                rndis_per_dev_params [configNr].dev->mtu);
@@ -253,7 +253,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
        /* mandatory */
        case OID_GEN_LINK_SPEED:
                if (rndis_debug > 1)
-                       DBG("%s: OID_GEN_LINK_SPEED\n", __FUNCTION__);
+                       DBG("%s: OID_GEN_LINK_SPEED\n", __func__);
                if (rndis_per_dev_params [configNr].media_state
                                == NDIS_MEDIA_STATE_DISCONNECTED)
                        *outbuf = __constant_cpu_to_le32 (0);
@@ -265,7 +265,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
 
        /* mandatory */
        case OID_GEN_TRANSMIT_BLOCK_SIZE:
-               DBG("%s: OID_GEN_TRANSMIT_BLOCK_SIZE\n", __FUNCTION__);
+               DBG("%s: OID_GEN_TRANSMIT_BLOCK_SIZE\n", __func__);
                if (rndis_per_dev_params [configNr].dev) {
                        *outbuf = cpu_to_le32 (
                                rndis_per_dev_params [configNr].dev->mtu);
@@ -275,7 +275,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
 
        /* mandatory */
        case OID_GEN_RECEIVE_BLOCK_SIZE:
-               DBG("%s: OID_GEN_RECEIVE_BLOCK_SIZE\n", __FUNCTION__);
+               DBG("%s: OID_GEN_RECEIVE_BLOCK_SIZE\n", __func__);
                if (rndis_per_dev_params [configNr].dev) {
                        *outbuf = cpu_to_le32 (
                                rndis_per_dev_params [configNr].dev->mtu);
@@ -285,7 +285,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
 
        /* mandatory */
        case OID_GEN_VENDOR_ID:
-               DBG("%s: OID_GEN_VENDOR_ID\n", __FUNCTION__);
+               DBG("%s: OID_GEN_VENDOR_ID\n", __func__);
                *outbuf = cpu_to_le32 (
                        rndis_per_dev_params [configNr].vendorID);
                retval = 0;
@@ -293,7 +293,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
 
        /* mandatory */
        case OID_GEN_VENDOR_DESCRIPTION:
-               DBG("%s: OID_GEN_VENDOR_DESCRIPTION\n", __FUNCTION__);
+               DBG("%s: OID_GEN_VENDOR_DESCRIPTION\n", __func__);
                length = strlen (rndis_per_dev_params [configNr].vendorDescr);
                memcpy (outbuf,
                        rndis_per_dev_params [configNr].vendorDescr, length);
@@ -301,7 +301,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
                break;
 
        case OID_GEN_VENDOR_DRIVER_VERSION:
-               DBG("%s: OID_GEN_VENDOR_DRIVER_VERSION\n", __FUNCTION__);
+               DBG("%s: OID_GEN_VENDOR_DRIVER_VERSION\n", __func__);
                /* Created as LE */
                *outbuf = rndis_driver_version;
                retval = 0;
@@ -309,14 +309,14 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
 
        /* mandatory */
        case OID_GEN_CURRENT_PACKET_FILTER:
-               DBG("%s: OID_GEN_CURRENT_PACKET_FILTER\n", __FUNCTION__);
+               DBG("%s: OID_GEN_CURRENT_PACKET_FILTER\n", __func__);
                *outbuf = cpu_to_le32 (*rndis_per_dev_params[configNr].filter);
                retval = 0;
                break;
 
        /* mandatory */
        case OID_GEN_MAXIMUM_TOTAL_SIZE:
-               DBG("%s: OID_GEN_MAXIMUM_TOTAL_SIZE\n", __FUNCTION__);
+               DBG("%s: OID_GEN_MAXIMUM_TOTAL_SIZE\n", __func__);
                *outbuf = __constant_cpu_to_le32(RNDIS_MAX_TOTAL_SIZE);
                retval = 0;
                break;
@@ -324,14 +324,14 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
        /* mandatory */
        case OID_GEN_MEDIA_CONNECT_STATUS:
                if (rndis_debug > 1)
-                       DBG("%s: OID_GEN_MEDIA_CONNECT_STATUS\n", __FUNCTION__);
+                       DBG("%s: OID_GEN_MEDIA_CONNECT_STATUS\n", __func__);
                *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
                                                .media_state);
                retval = 0;
                break;
 
        case OID_GEN_PHYSICAL_MEDIUM:
-               DBG("%s: OID_GEN_PHYSICAL_MEDIUM\n", __FUNCTION__);
+               DBG("%s: OID_GEN_PHYSICAL_MEDIUM\n", __func__);
                *outbuf = __constant_cpu_to_le32 (0);
                retval = 0;
                break;
@@ -341,7 +341,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
         * versions emit undefined RNDIS messages. DOCUMENT ALL THESE!
         */
        case OID_GEN_MAC_OPTIONS:               /* from WinME */
-               DBG("%s: OID_GEN_MAC_OPTIONS\n", __FUNCTION__);
+               DBG("%s: OID_GEN_MAC_OPTIONS\n", __func__);
                *outbuf = __constant_cpu_to_le32(
                          NDIS_MAC_OPTION_RECEIVE_SERIALIZED
                        | NDIS_MAC_OPTION_FULL_DUPLEX);
@@ -353,7 +353,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
        /* mandatory */
        case OID_GEN_XMIT_OK:
                if (rndis_debug > 1)
-                       DBG("%s: OID_GEN_XMIT_OK\n", __FUNCTION__);
+                       DBG("%s: OID_GEN_XMIT_OK\n", __func__);
                if (rndis_per_dev_params [configNr].stats) {
                        *outbuf = cpu_to_le32 (
                            rndis_per_dev_params [configNr].stats->tx_packets -
@@ -366,7 +366,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
        /* mandatory */
        case OID_GEN_RCV_OK:
                if (rndis_debug > 1)
-                       DBG("%s: OID_GEN_RCV_OK\n", __FUNCTION__);
+                       DBG("%s: OID_GEN_RCV_OK\n", __func__);
                if (rndis_per_dev_params [configNr].stats) {
                        *outbuf = cpu_to_le32 (
                            rndis_per_dev_params [configNr].stats->rx_packets -
@@ -379,7 +379,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
        /* mandatory */
        case OID_GEN_XMIT_ERROR:
                if (rndis_debug > 1)
-                       DBG("%s: OID_GEN_XMIT_ERROR\n", __FUNCTION__);
+                       DBG("%s: OID_GEN_XMIT_ERROR\n", __func__);
                if (rndis_per_dev_params [configNr].stats) {
                        *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
                                        .stats->tx_errors);
@@ -390,7 +390,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
        /* mandatory */
        case OID_GEN_RCV_ERROR:
                if (rndis_debug > 1)
-                       DBG("%s: OID_GEN_RCV_ERROR\n", __FUNCTION__);
+                       DBG("%s: OID_GEN_RCV_ERROR\n", __func__);
                if (rndis_per_dev_params [configNr].stats) {
                        *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
                                        .stats->rx_errors);
@@ -400,7 +400,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
 
        /* mandatory */
        case OID_GEN_RCV_NO_BUFFER:
-               DBG("%s: OID_GEN_RCV_NO_BUFFER\n", __FUNCTION__);
+               DBG("%s: OID_GEN_RCV_NO_BUFFER\n", __func__);
                if (rndis_per_dev_params [configNr].stats) {
                        *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
                                        .stats->rx_dropped);
@@ -410,7 +410,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
 
 #ifdef RNDIS_OPTIONAL_STATS
        case OID_GEN_DIRECTED_BYTES_XMIT:
-               DBG("%s: OID_GEN_DIRECTED_BYTES_XMIT\n", __FUNCTION__);
+               DBG("%s: OID_GEN_DIRECTED_BYTES_XMIT\n", __func__);
                /*
                 * Aunt Tilly's size of shoes
                 * minus antarctica count of penguins
@@ -430,7 +430,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
                break;
 
        case OID_GEN_DIRECTED_FRAMES_XMIT:
-               DBG("%s: OID_GEN_DIRECTED_FRAMES_XMIT\n", __FUNCTION__);
+               DBG("%s: OID_GEN_DIRECTED_FRAMES_XMIT\n", __func__);
                /* dito */
                if (rndis_per_dev_params [configNr].stats) {
                        *outbuf = cpu_to_le32 (
@@ -446,7 +446,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
                break;
 
        case OID_GEN_MULTICAST_BYTES_XMIT:
-               DBG("%s: OID_GEN_MULTICAST_BYTES_XMIT\n", __FUNCTION__);
+               DBG("%s: OID_GEN_MULTICAST_BYTES_XMIT\n", __func__);
                if (rndis_per_dev_params [configNr].stats) {
                        *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
                                        .stats->multicast*1234);
@@ -455,7 +455,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
                break;
 
        case OID_GEN_MULTICAST_FRAMES_XMIT:
-               DBG("%s: OID_GEN_MULTICAST_FRAMES_XMIT\n", __FUNCTION__);
+               DBG("%s: OID_GEN_MULTICAST_FRAMES_XMIT\n", __func__);
                if (rndis_per_dev_params [configNr].stats) {
                        *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
                                        .stats->multicast);
@@ -464,7 +464,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
                break;
 
        case OID_GEN_BROADCAST_BYTES_XMIT:
-               DBG("%s: OID_GEN_BROADCAST_BYTES_XMIT\n", __FUNCTION__);
+               DBG("%s: OID_GEN_BROADCAST_BYTES_XMIT\n", __func__);
                if (rndis_per_dev_params [configNr].stats) {
                        *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
                                        .stats->tx_packets/42*255);
@@ -473,7 +473,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
                break;
 
        case OID_GEN_BROADCAST_FRAMES_XMIT:
-               DBG("%s: OID_GEN_BROADCAST_FRAMES_XMIT\n", __FUNCTION__);
+               DBG("%s: OID_GEN_BROADCAST_FRAMES_XMIT\n", __func__);
                if (rndis_per_dev_params [configNr].stats) {
                        *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
                                        .stats->tx_packets/42);
@@ -482,19 +482,19 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
                break;
 
        case OID_GEN_DIRECTED_BYTES_RCV:
-               DBG("%s: OID_GEN_DIRECTED_BYTES_RCV\n", __FUNCTION__);
+               DBG("%s: OID_GEN_DIRECTED_BYTES_RCV\n", __func__);
                *outbuf = __constant_cpu_to_le32 (0);
                retval = 0;
                break;
 
        case OID_GEN_DIRECTED_FRAMES_RCV:
-               DBG("%s: OID_GEN_DIRECTED_FRAMES_RCV\n", __FUNCTION__);
+               DBG("%s: OID_GEN_DIRECTED_FRAMES_RCV\n", __func__);
                *outbuf = __constant_cpu_to_le32 (0);
                retval = 0;
                break;
 
        case OID_GEN_MULTICAST_BYTES_RCV:
-               DBG("%s: OID_GEN_MULTICAST_BYTES_RCV\n", __FUNCTION__);
+               DBG("%s: OID_GEN_MULTICAST_BYTES_RCV\n", __func__);
                if (rndis_per_dev_params [configNr].stats) {
                        *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
                                        .stats->multicast * 1111);
@@ -503,7 +503,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
                break;
 
        case OID_GEN_MULTICAST_FRAMES_RCV:
-               DBG("%s: OID_GEN_MULTICAST_FRAMES_RCV\n", __FUNCTION__);
+               DBG("%s: OID_GEN_MULTICAST_FRAMES_RCV\n", __func__);
                if (rndis_per_dev_params [configNr].stats) {
                        *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
                                        .stats->multicast);
@@ -512,7 +512,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
                break;
 
        case OID_GEN_BROADCAST_BYTES_RCV:
-               DBG("%s: OID_GEN_BROADCAST_BYTES_RCV\n", __FUNCTION__);
+               DBG("%s: OID_GEN_BROADCAST_BYTES_RCV\n", __func__);
                if (rndis_per_dev_params [configNr].stats) {
                        *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
                                        .stats->rx_packets/42*255);
@@ -521,7 +521,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
                break;
 
        case OID_GEN_BROADCAST_FRAMES_RCV:
-               DBG("%s: OID_GEN_BROADCAST_FRAMES_RCV\n", __FUNCTION__);
+               DBG("%s: OID_GEN_BROADCAST_FRAMES_RCV\n", __func__);
                if (rndis_per_dev_params [configNr].stats) {
                        *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
                                        .stats->rx_packets/42);
@@ -530,7 +530,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
                break;
 
        case OID_GEN_RCV_CRC_ERROR:
-               DBG("%s: OID_GEN_RCV_CRC_ERROR\n", __FUNCTION__);
+               DBG("%s: OID_GEN_RCV_CRC_ERROR\n", __func__);
                if (rndis_per_dev_params [configNr].stats) {
                        *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
                                        .stats->rx_crc_errors);
@@ -539,7 +539,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
                break;
 
        case OID_GEN_TRANSMIT_QUEUE_LENGTH:
-               DBG("%s: OID_GEN_TRANSMIT_QUEUE_LENGTH\n", __FUNCTION__);
+               DBG("%s: OID_GEN_TRANSMIT_QUEUE_LENGTH\n", __func__);
                *outbuf = __constant_cpu_to_le32 (0);
                retval = 0;
                break;
@@ -549,7 +549,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
 
        /* mandatory */
        case OID_802_3_PERMANENT_ADDRESS:
-               DBG("%s: OID_802_3_PERMANENT_ADDRESS\n", __FUNCTION__);
+               DBG("%s: OID_802_3_PERMANENT_ADDRESS\n", __func__);
                if (rndis_per_dev_params [configNr].dev) {
                        length = ETH_ALEN;
                        memcpy (outbuf,
@@ -561,7 +561,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
 
        /* mandatory */
        case OID_802_3_CURRENT_ADDRESS:
-               DBG("%s: OID_802_3_CURRENT_ADDRESS\n", __FUNCTION__);
+               DBG("%s: OID_802_3_CURRENT_ADDRESS\n", __func__);
                if (rndis_per_dev_params [configNr].dev) {
                        length = ETH_ALEN;
                        memcpy (outbuf,
@@ -573,7 +573,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
 
        /* mandatory */
        case OID_802_3_MULTICAST_LIST:
-               DBG("%s: OID_802_3_MULTICAST_LIST\n", __FUNCTION__);
+               DBG("%s: OID_802_3_MULTICAST_LIST\n", __func__);
                /* Multicast base address only */
                *outbuf = __constant_cpu_to_le32 (0xE0000000);
                retval = 0;
@@ -581,21 +581,21 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
 
        /* mandatory */
        case OID_802_3_MAXIMUM_LIST_SIZE:
-               DBG("%s: OID_802_3_MAXIMUM_LIST_SIZE\n", __FUNCTION__);
+               DBG("%s: OID_802_3_MAXIMUM_LIST_SIZE\n", __func__);
                /* Multicast base address only */
                *outbuf = __constant_cpu_to_le32 (1);
                retval = 0;
                break;
 
        case OID_802_3_MAC_OPTIONS:
-               DBG("%s: OID_802_3_MAC_OPTIONS\n", __FUNCTION__);
+               DBG("%s: OID_802_3_MAC_OPTIONS\n", __func__);
                break;
 
        /* ieee802.3 statistics OIDs (table 4-4) */
 
        /* mandatory */
        case OID_802_3_RCV_ERROR_ALIGNMENT:
-               DBG("%s: OID_802_3_RCV_ERROR_ALIGNMENT\n", __FUNCTION__);
+               DBG("%s: OID_802_3_RCV_ERROR_ALIGNMENT\n", __func__);
                if (rndis_per_dev_params [configNr].stats) {
                        *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
                                        .stats->rx_frame_errors);
@@ -605,51 +605,51 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
 
        /* mandatory */
        case OID_802_3_XMIT_ONE_COLLISION:
-               DBG("%s: OID_802_3_XMIT_ONE_COLLISION\n", __FUNCTION__);
+               DBG("%s: OID_802_3_XMIT_ONE_COLLISION\n", __func__);
                *outbuf = __constant_cpu_to_le32 (0);
                retval = 0;
                break;
 
        /* mandatory */
        case OID_802_3_XMIT_MORE_COLLISIONS:
-               DBG("%s: OID_802_3_XMIT_MORE_COLLISIONS\n", __FUNCTION__);
+               DBG("%s: OID_802_3_XMIT_MORE_COLLISIONS\n", __func__);
                *outbuf = __constant_cpu_to_le32 (0);
                retval = 0;
                break;
 
 #ifdef RNDIS_OPTIONAL_STATS
        case OID_802_3_XMIT_DEFERRED:
-               DBG("%s: OID_802_3_XMIT_DEFERRED\n", __FUNCTION__);
+               DBG("%s: OID_802_3_XMIT_DEFERRED\n", __func__);
                /* TODO */
                break;
 
        case OID_802_3_XMIT_MAX_COLLISIONS:
-               DBG("%s: OID_802_3_XMIT_MAX_COLLISIONS\n", __FUNCTION__);
+               DBG("%s: OID_802_3_XMIT_MAX_COLLISIONS\n", __func__);
                /* TODO */
                break;
 
        case OID_802_3_RCV_OVERRUN:
-               DBG("%s: OID_802_3_RCV_OVERRUN\n", __FUNCTION__);
+               DBG("%s: OID_802_3_RCV_OVERRUN\n", __func__);
                /* TODO */
                break;
 
        case OID_802_3_XMIT_UNDERRUN:
-               DBG("%s: OID_802_3_XMIT_UNDERRUN\n", __FUNCTION__);
+               DBG("%s: OID_802_3_XMIT_UNDERRUN\n", __func__);
                /* TODO */
                break;
 
        case OID_802_3_XMIT_HEARTBEAT_FAILURE:
-               DBG("%s: OID_802_3_XMIT_HEARTBEAT_FAILURE\n", __FUNCTION__);
+               DBG("%s: OID_802_3_XMIT_HEARTBEAT_FAILURE\n", __func__);
                /* TODO */
                break;
 
        case OID_802_3_XMIT_TIMES_CRS_LOST:
-               DBG("%s: OID_802_3_XMIT_TIMES_CRS_LOST\n", __FUNCTION__);
+               DBG("%s: OID_802_3_XMIT_TIMES_CRS_LOST\n", __func__);
                /* TODO */
                break;
 
        case OID_802_3_XMIT_LATE_COLLISIONS:
-               DBG("%s: OID_802_3_XMIT_LATE_COLLISIONS\n", __FUNCTION__);
+               DBG("%s: OID_802_3_XMIT_LATE_COLLISIONS\n", __func__);
                /* TODO */
                break;
 #endif /* RNDIS_OPTIONAL_STATS */
@@ -657,7 +657,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
 #ifdef RNDIS_PM
        /* power management OIDs (table 4-5) */
        case OID_PNP_CAPABILITIES:
-               DBG("%s: OID_PNP_CAPABILITIES\n", __FUNCTION__);
+               DBG("%s: OID_PNP_CAPABILITIES\n", __func__);
 
                /* for now, no wakeup capabilities */
                length = sizeof (struct NDIS_PNP_CAPABILITIES);
@@ -665,7 +665,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
                retval = 0;
                break;
        case OID_PNP_QUERY_POWER:
-               DBG("%s: OID_PNP_QUERY_POWER D%d\n", __FUNCTION__,
+               DBG("%s: OID_PNP_QUERY_POWER D%d\n", __func__,
                                le32_to_cpu(get_unaligned((__le32 *)buf)) - 1);
                /* only suspend is a real power state, and
                 * it can't be entered by OID_PNP_SET_POWER...
@@ -677,7 +677,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
 
        default:
                pr_warning("%s: query unknown OID 0x%08X\n",
-                        __FUNCTION__, OID);
+                        __func__, OID);
        }
        if (retval < 0)
                length = 0;
@@ -729,7 +729,7 @@ static int gen_ndis_set_resp (u8 configNr, u32 OID, u8 *buf, u32 buf_len,
                *params->filter = (u16) le32_to_cpu(get_unaligned(
                                (__le32 *)buf));
                DBG("%s: OID_GEN_CURRENT_PACKET_FILTER %08x\n",
-                       __FUNCTION__, *params->filter);
+                       __func__, *params->filter);
 
                /* this call has a significant side effect:  it's
                 * what makes the packet flow start and stop, like
@@ -753,7 +753,7 @@ update_linkstate:
 
        case OID_802_3_MULTICAST_LIST:
                /* I think we can ignore this */
-               DBG("%s: OID_802_3_MULTICAST_LIST\n", __FUNCTION__);
+               DBG("%s: OID_802_3_MULTICAST_LIST\n", __func__);
                retval = 0;
                break;
 #if 0
@@ -762,7 +762,7 @@ update_linkstate:
                struct rndis_config_parameter   *param;
                param = (struct rndis_config_parameter *) buf;
                DBG("%s: OID_GEN_RNDIS_CONFIG_PARAMETER '%*s'\n",
-                       __FUNCTION__,
+                       __func__,
                        min(cpu_to_le32(param->ParameterNameLength),80),
                        buf + param->ParameterNameOffset);
                retval = 0;
@@ -778,7 +778,7 @@ update_linkstate:
                 * FIXME ... then things go batty; Windows wedges itself.
                 */
                i = le32_to_cpu(get_unaligned((__le32 *)buf));
-               DBG("%s: OID_PNP_SET_POWER D%d\n", __FUNCTION__, i - 1);
+               DBG("%s: OID_PNP_SET_POWER D%d\n", __func__, i - 1);
                switch (i) {
                case NdisDeviceStateD0:
                        *params->filter = params->saved_filter;
@@ -802,7 +802,7 @@ update_linkstate:
 
        default:
                pr_warning("%s: set unknown OID 0x%08X, size %d\n",
-                        __FUNCTION__, OID, buf_len);
+                        __func__, OID, buf_len);
        }
 
        return retval;
@@ -855,7 +855,7 @@ static int rndis_query_response (int configNr, rndis_query_msg_type *buf)
        rndis_query_cmplt_type *resp;
        rndis_resp_t            *r;
 
-       // DBG("%s: OID = %08X\n", __FUNCTION__, cpu_to_le32(buf->OID));
+       // DBG("%s: OID = %08X\n", __func__, cpu_to_le32(buf->OID));
        if (!rndis_per_dev_params [configNr].dev) return -ENOTSUPP;
 
        /*
@@ -908,9 +908,9 @@ static int rndis_set_response (int configNr, rndis_set_msg_type *buf)
        BufOffset = le32_to_cpu (buf->InformationBufferOffset);
 
 #ifdef VERBOSE
-       DBG("%s: Length: %d\n", __FUNCTION__, BufLength);
-       DBG("%s: Offset: %d\n", __FUNCTION__, BufOffset);
-       DBG("%s: InfoBuffer: ", __FUNCTION__);
+       DBG("%s: Length: %d\n", __func__, BufLength);
+       DBG("%s: Offset: %d\n", __func__, BufOffset);
+       DBG("%s: InfoBuffer: ", __func__);
 
        for (i = 0; i < BufLength; i++) {
                DBG("%02x ", *(((u8 *) buf) + i + 8 + BufOffset));
@@ -1080,14 +1080,14 @@ int rndis_msg_parser (u8 configNr, u8 *buf)
        switch (MsgType) {
        case REMOTE_NDIS_INITIALIZE_MSG:
                DBG("%s: REMOTE_NDIS_INITIALIZE_MSG\n",
-                       __FUNCTION__ );
+                       __func__ );
                params->state = RNDIS_INITIALIZED;
                return  rndis_init_response (configNr,
                                        (rndis_init_msg_type *) buf);
 
        case REMOTE_NDIS_HALT_MSG:
                DBG("%s: REMOTE_NDIS_HALT_MSG\n",
-                       __FUNCTION__ );
+                       __func__ );
                params->state = RNDIS_UNINITIALIZED;
                if (params->dev) {
                        netif_carrier_off (params->dev);
@@ -1105,7 +1105,7 @@ int rndis_msg_parser (u8 configNr, u8 *buf)
 
        case REMOTE_NDIS_RESET_MSG:
                DBG("%s: REMOTE_NDIS_RESET_MSG\n",
-                       __FUNCTION__ );
+                       __func__ );
                return rndis_reset_response (configNr,
                                        (rndis_reset_msg_type *) buf);
 
@@ -1113,7 +1113,7 @@ int rndis_msg_parser (u8 configNr, u8 *buf)
                /* For USB: host does this every 5 seconds */
                if (rndis_debug > 1)
                        DBG("%s: REMOTE_NDIS_KEEPALIVE_MSG\n",
-                               __FUNCTION__ );
+                               __func__ );
                return rndis_keepalive_response (configNr,
                                                 (rndis_keepalive_msg_type *)
                                                 buf);
@@ -1124,7 +1124,7 @@ int rndis_msg_parser (u8 configNr, u8 *buf)
                 * suspending itself.
                 */
                pr_warning("%s: unknown RNDIS message 0x%08X len %d\n",
-                       __FUNCTION__ , MsgType, MsgLength);
+                       __func__ , MsgType, MsgLength);
                {
                        unsigned i;
                        for (i = 0; i < MsgLength; i += 16) {
@@ -1159,7 +1159,7 @@ int rndis_register (int (* rndis_control_ack) (struct net_device *))
                if (!rndis_per_dev_params [i].used) {
                        rndis_per_dev_params [i].used = 1;
                        rndis_per_dev_params [i].ack = rndis_control_ack;
-                       DBG("%s: configNr = %d\n", __FUNCTION__, i);
+                       DBG("%s: configNr = %d\n", __func__, i);
                        return i;
                }
        }
@@ -1170,7 +1170,7 @@ int rndis_register (int (* rndis_control_ack) (struct net_device *))
 
 void rndis_deregister (int configNr)
 {
-       DBG("%s: \n", __FUNCTION__ );
+       DBG("%s: \n", __func__ );
 
        if (configNr >= RNDIS_MAX_CONFIGS) return;
        rndis_per_dev_params [configNr].used = 0;
@@ -1182,7 +1182,7 @@ int rndis_set_param_dev (u8 configNr, struct net_device *dev,
                         struct net_device_stats *stats,
                         u16 *cdc_filter)
 {
-       DBG("%s:\n", __FUNCTION__ );
+       DBG("%s:\n", __func__ );
        if (!dev || !stats) return -1;
        if (configNr >= RNDIS_MAX_CONFIGS) return -1;
 
@@ -1195,7 +1195,7 @@ int rndis_set_param_dev (u8 configNr, struct net_device *dev,
 
 int rndis_set_param_vendor (u8 configNr, u32 vendorID, const char *vendorDescr)
 {
-       DBG("%s:\n", __FUNCTION__ );
+       DBG("%s:\n", __func__ );
        if (!vendorDescr) return -1;
        if (configNr >= RNDIS_MAX_CONFIGS) return -1;
 
@@ -1207,7 +1207,7 @@ int rndis_set_param_vendor (u8 configNr, u32 vendorID, const char *vendorDescr)
 
 int rndis_set_param_medium (u8 configNr, u32 medium, u32 speed)
 {
-       DBG("%s: %u %u\n", __FUNCTION__, medium, speed);
+       DBG("%s: %u %u\n", __func__, medium, speed);
        if (configNr >= RNDIS_MAX_CONFIGS) return -1;
 
        rndis_per_dev_params [configNr].medium = medium;
@@ -1415,7 +1415,7 @@ int __init rndis_init (void)
                if (!(rndis_connect_state [i]
                                = create_proc_entry (name, 0660, NULL)))
                {
-                       DBG("%s :remove entries", __FUNCTION__);
+                       DBG("%s :remove entries", __func__);
                        while (i) {
                                sprintf (name, NAME_TEMPLATE, --i);
                                remove_proc_entry (name, NULL);
index 315c7c1..5ae6891 100644 (file)
@@ -251,7 +251,7 @@ __acquires(ehci->lock)
 #ifdef EHCI_URB_TRACE
        ehci_dbg (ehci,
                "%s %s urb %p ep%d%s status %d len %d/%d\n",
-               __FUNCTION__, urb->dev->devpath, urb,
+               __func__, urb->dev->devpath, urb,
                usb_pipeendpoint (urb->pipe),
                usb_pipein (urb->pipe) ? "in" : "out",
                status,
@@ -974,7 +974,7 @@ submit_async (
 #ifdef EHCI_URB_TRACE
        ehci_dbg (ehci,
                "%s %s urb %p ep%d%s len %d, qtd %p [qh %p]\n",
-               __FUNCTION__, urb->dev->devpath, urb,
+               __func__, urb->dev->devpath, urb,
                epnum & 0x0f, (epnum & USB_DIR_IN) ? "in" : "out",
                urb->transfer_buffer_length,
                qtd, urb->ep->hcpriv);
index e3cfe0a..be575e4 100644 (file)
@@ -1677,7 +1677,7 @@ static int itd_submit (struct ehci_hcd *ehci, struct urb *urb,
 #ifdef EHCI_URB_TRACE
        ehci_dbg (ehci,
                "%s %s urb %p ep%d%s len %d, %d pkts %d uframes [%p]\n",
-               __FUNCTION__, urb->dev->devpath, urb,
+               __func__, urb->dev->devpath, urb,
                usb_pipeendpoint (urb->pipe),
                usb_pipein (urb->pipe) ? "in" : "out",
                urb->transfer_buffer_length,
index 0ee694f..ae6e70e 100644 (file)
@@ -106,7 +106,7 @@ int uhci_check_and_reset_hc(struct pci_dev *pdev, unsigned long base)
        pci_read_config_word(pdev, UHCI_USBLEGSUP, &legsup);
        if (legsup & ~(UHCI_USBLEGSUP_RO | UHCI_USBLEGSUP_RWC)) {
                dev_dbg(&pdev->dev, "%s: legsup = 0x%04x\n",
-                               __FUNCTION__, legsup);
+                               __func__, legsup);
                goto reset_needed;
        }
 
@@ -114,14 +114,14 @@ int uhci_check_and_reset_hc(struct pci_dev *pdev, unsigned long base)
        if ((cmd & UHCI_USBCMD_RUN) || !(cmd & UHCI_USBCMD_CONFIGURE) ||
                        !(cmd & UHCI_USBCMD_EGSM)) {
                dev_dbg(&pdev->dev, "%s: cmd = 0x%04x\n",
-                               __FUNCTION__, cmd);
+                               __func__, cmd);
                goto reset_needed;
        }
 
        intr = inw(base + UHCI_USBINTR);
        if (intr & (~UHCI_USBINTR_RESUME)) {
                dev_dbg(&pdev->dev, "%s: intr = 0x%04x\n",
-                               __FUNCTION__, intr);
+                               __func__, intr);
                goto reset_needed;
        }
        return 0;
index df256d6..274276c 100644 (file)
@@ -1335,7 +1335,7 @@ static int
 sl811h_bus_suspend(struct usb_hcd *hcd)
 {
        // SOFs off
-       DBG("%s\n", __FUNCTION__);
+       DBG("%s\n", __func__);
        return 0;
 }
 
@@ -1343,7 +1343,7 @@ static int
 sl811h_bus_resume(struct usb_hcd *hcd)
 {
        // SOFs on
-       DBG("%s\n", __FUNCTION__);
+       DBG("%s\n", __func__);
        return 0;
 }
 
index f65d5a8..d3e0d8a 100644 (file)
@@ -335,7 +335,7 @@ __releases(uhci->lock)
 __acquires(uhci->lock)
 {
        dev_dbg(&uhci_to_hcd(uhci)->self.root_hub->dev,
-                       "%s%s\n", __FUNCTION__,
+                       "%s%s\n", __func__,
                        uhci->rh_state == UHCI_RH_AUTO_STOPPED ?
                                " (auto-start)" : "");
 
@@ -735,7 +735,7 @@ static int uhci_pci_suspend(struct usb_hcd *hcd, pm_message_t message)
        struct uhci_hcd *uhci = hcd_to_uhci(hcd);
        int rc = 0;
 
-       dev_dbg(uhci_dev(uhci), "%s\n", __FUNCTION__);
+       dev_dbg(uhci_dev(uhci), "%s\n", __func__);
 
        spin_lock_irq(&uhci->lock);
        if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags) || uhci->dead)
@@ -771,7 +771,7 @@ static int uhci_pci_resume(struct usb_hcd *hcd)
 {
        struct uhci_hcd *uhci = hcd_to_uhci(hcd);
 
-       dev_dbg(uhci_dev(uhci), "%s\n", __FUNCTION__);
+       dev_dbg(uhci_dev(uhci), "%s\n", __func__);
 
        /* Since we aren't in D3 any more, it's safe to set this flag
         * even if the controller was dead.
index 60379b1..db64593 100644 (file)
@@ -1171,7 +1171,7 @@ static int uhci_result_common(struct uhci_hcd *uhci, struct urb *urb)
                                /* Some debugging code */
                                dev_dbg(&urb->dev->dev,
                                                "%s: failed with status %x\n",
-                                               __FUNCTION__, status);
+                                               __func__, status);
 
                                if (debug > 1 && errbuf) {
                                        /* Print the chain for debugging */
index 5a2c44e..965f6ea 100644 (file)
@@ -147,10 +147,10 @@ static void adu_abort_transfers(struct adu_device *dev)
 {
        unsigned long flags;
 
-       dbg(2," %s : enter", __FUNCTION__);
+       dbg(2," %s : enter", __func__);
 
        if (dev->udev == NULL) {
-               dbg(1," %s : udev is null", __FUNCTION__);
+               dbg(1," %s : udev is null", __func__);
                goto exit;
        }
 
@@ -172,12 +172,12 @@ static void adu_abort_transfers(struct adu_device *dev)
                spin_unlock_irqrestore(&dev->buflock, flags);
 
 exit:
-       dbg(2," %s : leave", __FUNCTION__);
+       dbg(2," %s : leave", __func__);
 }
 
 static void adu_delete(struct adu_device *dev)
 {
-       dbg(2, "%s enter", __FUNCTION__);
+       dbg(2, "%s enter", __func__);
 
        /* free data structures */
        usb_free_urb(dev->interrupt_in_urb);
@@ -188,7 +188,7 @@ static void adu_delete(struct adu_device *dev)
        kfree(dev->interrupt_out_buffer);
        kfree(dev);
 
-       dbg(2, "%s : leave", __FUNCTION__);
+       dbg(2, "%s : leave", __func__);
 }
 
 static void adu_interrupt_in_callback(struct urb *urb)
@@ -196,8 +196,8 @@ static void adu_interrupt_in_callback(struct urb *urb)
        struct adu_device *dev = urb->context;
        int status = urb->status;
 
-       dbg(4," %s : enter, status %d", __FUNCTION__, status);
-       adu_debug_data(5, __FUNCTION__, urb->actual_length,
+       dbg(4," %s : enter, status %d", __func__, status);
+       adu_debug_data(5, __func__, urb->actual_length,
                       urb->transfer_buffer);
 
        spin_lock(&dev->buflock);
@@ -206,7 +206,7 @@ static void adu_interrupt_in_callback(struct urb *urb)
                if ((status != -ENOENT) && (status != -ECONNRESET) &&
                        (status != -ESHUTDOWN)) {
                        dbg(1," %s : nonzero status received: %d",
-                           __FUNCTION__, status);
+                           __func__, status);
                }
                goto exit;
        }
@@ -220,10 +220,10 @@ static void adu_interrupt_in_callback(struct urb *urb)
                                dev->interrupt_in_buffer, urb->actual_length);
 
                        dev->read_buffer_length += urb->actual_length;
-                       dbg(2," %s reading  %d ", __FUNCTION__,
+                       dbg(2," %s reading  %d ", __func__,
                            urb->actual_length);
                } else {
-                       dbg(1," %s : read_buffer overflow", __FUNCTION__);
+                       dbg(1," %s : read_buffer overflow", __func__);
                }
        }
 
@@ -232,9 +232,9 @@ exit:
        spin_unlock(&dev->buflock);
        /* always wake up so we recover from errors */
        wake_up_interruptible(&dev->read_wait);
-       adu_debug_data(5, __FUNCTION__, urb->actual_length,
+       adu_debug_data(5, __func__, urb->actual_length,
                       urb->transfer_buffer);
-       dbg(4," %s : leave, status %d", __FUNCTION__, status);
+       dbg(4," %s : leave, status %d", __func__, status);
 }
 
 static void adu_interrupt_out_callback(struct urb *urb)
@@ -242,14 +242,14 @@ static void adu_interrupt_out_callback(struct urb *urb)
        struct adu_device *dev = urb->context;
        int status = urb->status;
 
-       dbg(4," %s : enter, status %d", __FUNCTION__, status);
-       adu_debug_data(5,__FUNCTION__, urb->actual_length, urb->transfer_buffer);
+       dbg(4," %s : enter, status %d", __func__, status);
+       adu_debug_data(5,__func__, urb->actual_length, urb->transfer_buffer);
 
        if (status != 0) {
                if ((status != -ENOENT) &&
                    (status != -ECONNRESET)) {
                        dbg(1, " %s :nonzero status received: %d",
-                           __FUNCTION__, status);
+                           __func__, status);
                }
                goto exit;
        }
@@ -260,9 +260,9 @@ static void adu_interrupt_out_callback(struct urb *urb)
        spin_unlock(&dev->buflock);
 exit:
 
-       adu_debug_data(5, __FUNCTION__, urb->actual_length,
+       adu_debug_data(5, __func__, urb->actual_length,
                       urb->transfer_buffer);
-       dbg(4," %s : leave, status %d", __FUNCTION__, status);
+       dbg(4," %s : leave, status %d", __func__, status);
 }
 
 static int adu_open(struct inode *inode, struct file *file)
@@ -272,19 +272,19 @@ static int adu_open(struct inode *inode, struct file *file)
        int subminor;
        int retval;
 
-       dbg(2,"%s : enter", __FUNCTION__);
+       dbg(2,"%s : enter", __func__);
 
        subminor = iminor(inode);
 
        if ((retval = mutex_lock_interruptible(&adutux_mutex))) {
-               dbg(2, "%s : mutex lock failed", __FUNCTION__);
+               dbg(2, "%s : mutex lock failed", __func__);
                goto exit_no_lock;
        }
 
        interface = usb_find_interface(&adu_driver, subminor);
        if (!interface) {
                err("%s - error, can't find device for minor %d",
-                   __FUNCTION__, subminor);
+                   __func__, subminor);
                retval = -ENODEV;
                goto exit_no_device;
        }
@@ -302,7 +302,7 @@ static int adu_open(struct inode *inode, struct file *file)
        }
 
        ++dev->open_count;
-       dbg(2,"%s : open count %d", __FUNCTION__, dev->open_count);
+       dbg(2,"%s : open count %d", __func__, dev->open_count);
 
        /* save device in the file's private structure */
        file->private_data = dev;
@@ -332,23 +332,23 @@ static int adu_open(struct inode *inode, struct file *file)
 exit_no_device:
        mutex_unlock(&adutux_mutex);
 exit_no_lock:
-       dbg(2,"%s : leave, return value %d ", __FUNCTION__, retval);
+       dbg(2,"%s : leave, return value %d ", __func__, retval);
        return retval;
 }
 
 static void adu_release_internal(struct adu_device *dev)
 {
-       dbg(2," %s : enter", __FUNCTION__);
+       dbg(2," %s : enter", __func__);
 
        /* decrement our usage count for the device */
        --dev->open_count;
-       dbg(2," %s : open count %d", __FUNCTION__, dev->open_count);
+       dbg(2," %s : open count %d", __func__, dev->open_count);
        if (dev->open_count <= 0) {
                adu_abort_transfers(dev);
                dev->open_count = 0;
        }
 
-       dbg(2," %s : leave", __FUNCTION__);
+       dbg(2," %s : leave", __func__);
 }
 
 static int adu_release(struct inode *inode, struct file *file)
@@ -356,17 +356,17 @@ static int adu_release(struct inode *inode, struct file *file)
        struct adu_device *dev;
        int retval = 0;
 
-       dbg(2," %s : enter", __FUNCTION__);
+       dbg(2," %s : enter", __func__);
 
        if (file == NULL) {
-               dbg(1," %s : file is NULL", __FUNCTION__);
+               dbg(1," %s : file is NULL", __func__);
                retval = -ENODEV;
                goto exit;
        }
 
        dev = file->private_data;
        if (dev == NULL) {
-               dbg(1," %s : object is NULL", __FUNCTION__);
+               dbg(1," %s : object is NULL", __func__);
                retval = -ENODEV;
                goto exit;
        }
@@ -374,7 +374,7 @@ static int adu_release(struct inode *inode, struct file *file)
        mutex_lock(&adutux_mutex); /* not interruptible */
 
        if (dev->open_count <= 0) {
-               dbg(1," %s : device not opened", __FUNCTION__);
+               dbg(1," %s : device not opened", __func__);
                retval = -ENODEV;
                goto exit;
        }
@@ -388,7 +388,7 @@ static int adu_release(struct inode *inode, struct file *file)
 
 exit:
        mutex_unlock(&adutux_mutex);
-       dbg(2," %s : leave, return value %d", __FUNCTION__, retval);
+       dbg(2," %s : leave, return value %d", __func__, retval);
        return retval;
 }
 
@@ -405,10 +405,10 @@ static ssize_t adu_read(struct file *file, __user char *buffer, size_t count,
        unsigned long flags;
        DECLARE_WAITQUEUE(wait, current);
 
-       dbg(2," %s : enter, count = %Zd, file=%p", __FUNCTION__, count, file);
+       dbg(2," %s : enter, count = %Zd, file=%p", __func__, count, file);
 
        dev = file->private_data;
-       dbg(2," %s : dev=%p", __FUNCTION__, dev);
+       dbg(2," %s : dev=%p", __func__, dev);
 
        if (mutex_lock_interruptible(&dev->mtx))
                return -ERESTARTSYS;
@@ -422,16 +422,16 @@ static ssize_t adu_read(struct file *file, __user char *buffer, size_t count,
 
        /* verify that some data was requested */
        if (count == 0) {
-               dbg(1," %s : read request of 0 bytes", __FUNCTION__);
+               dbg(1," %s : read request of 0 bytes", __func__);
                goto exit;
        }
 
        timeout = COMMAND_TIMEOUT;
-       dbg(2," %s : about to start looping", __FUNCTION__);
+       dbg(2," %s : about to start looping", __func__);
        while (bytes_to_read) {
                int data_in_secondary = dev->secondary_tail - dev->secondary_head;
                dbg(2," %s : while, data_in_secondary=%d, status=%d",
-                   __FUNCTION__, data_in_secondary,
+                   __func__, data_in_secondary,
                    dev->interrupt_in_urb->status);
 
                if (data_in_secondary) {
@@ -456,7 +456,7 @@ static ssize_t adu_read(struct file *file, __user char *buffer, size_t count,
                                /* we secure access to the primary */
                                char *tmp;
                                dbg(2," %s : swap, read_buffer_length = %d",
-                                   __FUNCTION__, dev->read_buffer_length);
+                                   __func__, dev->read_buffer_length);
                                tmp = dev->read_buffer_secondary;
                                dev->read_buffer_secondary = dev->read_buffer_primary;
                                dev->read_buffer_primary = tmp;
@@ -471,10 +471,10 @@ static ssize_t adu_read(struct file *file, __user char *buffer, size_t count,
                                if (!dev->read_urb_finished) {
                                        /* somebody is doing IO */
                                        spin_unlock_irqrestore(&dev->buflock, flags);
-                                       dbg(2," %s : submitted already", __FUNCTION__);
+                                       dbg(2," %s : submitted already", __func__);
                                } else {
                                        /* we must initiate input */
-                                       dbg(2," %s : initiate input", __FUNCTION__);
+                                       dbg(2," %s : initiate input", __func__);
                                        dev->read_urb_finished = 0;
                                        spin_unlock_irqrestore(&dev->buflock, flags);
 
@@ -492,7 +492,7 @@ static ssize_t adu_read(struct file *file, __user char *buffer, size_t count,
                                                if (retval == -ENOMEM) {
                                                        retval = bytes_read ? bytes_read : -ENOMEM;
                                                }
-                                               dbg(2," %s : submit failed", __FUNCTION__);
+                                               dbg(2," %s : submit failed", __func__);
                                                goto exit;
                                        }
                                }
@@ -511,13 +511,13 @@ static ssize_t adu_read(struct file *file, __user char *buffer, size_t count,
                                remove_wait_queue(&dev->read_wait, &wait);
 
                                if (timeout <= 0) {
-                                       dbg(2," %s : timeout", __FUNCTION__);
+                                       dbg(2," %s : timeout", __func__);
                                        retval = bytes_read ? bytes_read : -ETIMEDOUT;
                                        goto exit;
                                }
 
                                if (signal_pending(current)) {
-                                       dbg(2," %s : signal pending", __FUNCTION__);
+                                       dbg(2," %s : signal pending", __func__);
                                        retval = bytes_read ? bytes_read : -EINTR;
                                        goto exit;
                                }
@@ -550,7 +550,7 @@ exit:
        /* unlock the device */
        mutex_unlock(&dev->mtx);
 
-       dbg(2," %s : leave, return value %d", __FUNCTION__, retval);
+       dbg(2," %s : leave, return value %d", __func__, retval);
        return retval;
 }
 
@@ -565,7 +565,7 @@ static ssize_t adu_write(struct file *file, const __user char *buffer,
        unsigned long flags;
        int retval;
 
-       dbg(2," %s : enter, count = %Zd", __FUNCTION__, count);
+       dbg(2," %s : enter, count = %Zd", __func__, count);
 
        dev = file->private_data;
 
@@ -582,7 +582,7 @@ static ssize_t adu_write(struct file *file, const __user char *buffer,
 
        /* verify that we actually have some data to write */
        if (count == 0) {
-               dbg(1," %s : write request of 0 bytes", __FUNCTION__);
+               dbg(1," %s : write request of 0 bytes", __func__);
                goto exit;
        }
 
@@ -595,13 +595,13 @@ static ssize_t adu_write(struct file *file, const __user char *buffer,
 
                        mutex_unlock(&dev->mtx);
                        if (signal_pending(current)) {
-                               dbg(1," %s : interrupted", __FUNCTION__);
+                               dbg(1," %s : interrupted", __func__);
                                set_current_state(TASK_RUNNING);
                                retval = -EINTR;
                                goto exit_onqueue;
                        }
                        if (schedule_timeout(COMMAND_TIMEOUT) == 0) {
-                               dbg(1, "%s - command timed out.", __FUNCTION__);
+                               dbg(1, "%s - command timed out.", __func__);
                                retval = -ETIMEDOUT;
                                goto exit_onqueue;
                        }
@@ -612,18 +612,18 @@ static ssize_t adu_write(struct file *file, const __user char *buffer,
                                goto exit_nolock;
                        }
 
-                       dbg(4," %s : in progress, count = %Zd", __FUNCTION__, count);
+                       dbg(4," %s : in progress, count = %Zd", __func__, count);
                } else {
                        spin_unlock_irqrestore(&dev->buflock, flags);
                        set_current_state(TASK_RUNNING);
                        remove_wait_queue(&dev->write_wait, &waita);
-                       dbg(4," %s : sending, count = %Zd", __FUNCTION__, count);
+                       dbg(4," %s : sending, count = %Zd", __func__, count);
 
                        /* write the data into interrupt_out_buffer from userspace */
                        buffer_size = le16_to_cpu(dev->interrupt_out_endpoint->wMaxPacketSize);
                        bytes_to_write = count > buffer_size ? buffer_size : count;
                        dbg(4," %s : buffer_size = %Zd, count = %Zd, bytes_to_write = %Zd",
-                           __FUNCTION__, buffer_size, count, bytes_to_write);
+                           __func__, buffer_size, count, bytes_to_write);
 
                        if (copy_from_user(dev->interrupt_out_buffer, buffer, bytes_to_write) != 0) {
                                retval = -EFAULT;
@@ -661,7 +661,7 @@ static ssize_t adu_write(struct file *file, const __user char *buffer,
 exit:
        mutex_unlock(&dev->mtx);
 exit_nolock:
-       dbg(2," %s : leave, return value %d", __FUNCTION__, retval);
+       dbg(2," %s : leave, return value %d", __func__, retval);
        return retval;
 
 exit_onqueue:
@@ -706,7 +706,7 @@ static int adu_probe(struct usb_interface *interface,
        int out_end_size;
        int i;
 
-       dbg(2," %s : enter", __FUNCTION__);
+       dbg(2," %s : enter", __func__);
 
        if (udev == NULL) {
                dev_err(&interface->dev, "udev is NULL.\n");
@@ -807,7 +807,7 @@ static int adu_probe(struct usb_interface *interface,
                dev_err(&interface->dev, "Could not retrieve serial number\n");
                goto error;
        }
-       dbg(2," %s : serial_number=%s", __FUNCTION__, dev->serial_number);
+       dbg(2," %s : serial_number=%s", __func__, dev->serial_number);
 
        /* we can register the device now, as it is ready */
        usb_set_intfdata(interface, dev);
@@ -828,7 +828,7 @@ static int adu_probe(struct usb_interface *interface,
                 udev->descriptor.idProduct, dev->serial_number,
                 (dev->minor - ADU_MINOR_BASE));
 exit:
-       dbg(2," %s : leave, return value %p (dev)", __FUNCTION__, dev);
+       dbg(2," %s : leave, return value %p (dev)", __func__, dev);
 
        return retval;
 
@@ -847,7 +847,7 @@ static void adu_disconnect(struct usb_interface *interface)
        struct adu_device *dev;
        int minor;
 
-       dbg(2," %s : enter", __FUNCTION__);
+       dbg(2," %s : enter", __func__);
 
        dev = usb_get_intfdata(interface);
 
@@ -861,7 +861,7 @@ static void adu_disconnect(struct usb_interface *interface)
        usb_set_intfdata(interface, NULL);
 
        /* if the device is not opened, then we clean up right now */
-       dbg(2," %s : open count %d", __FUNCTION__, dev->open_count);
+       dbg(2," %s : open count %d", __func__, dev->open_count);
        if (!dev->open_count)
                adu_delete(dev);
 
@@ -870,7 +870,7 @@ static void adu_disconnect(struct usb_interface *interface)
        dev_info(&interface->dev, "ADU device adutux%d now disconnected\n",
                 (minor - ADU_MINOR_BASE));
 
-       dbg(2," %s : leave", __FUNCTION__);
+       dbg(2," %s : leave", __func__);
 }
 
 /* usb specific object needed to register this driver with the usb subsystem */
@@ -885,7 +885,7 @@ static int __init adu_init(void)
 {
        int result;
 
-       dbg(2," %s : enter", __FUNCTION__);
+       dbg(2," %s : enter", __func__);
 
        /* register this driver with the USB subsystem */
        result = usb_register(&adu_driver);
@@ -899,17 +899,17 @@ static int __init adu_init(void)
        info("adutux is an experimental driver. Use at your own risk");
 
 exit:
-       dbg(2," %s : leave, return value %d", __FUNCTION__, result);
+       dbg(2," %s : leave, return value %d", __func__, result);
 
        return result;
 }
 
 static void __exit adu_exit(void)
 {
-       dbg(2," %s : enter", __FUNCTION__);
+       dbg(2," %s : enter", __func__);
        /* deregister this driver with the USB subsystem */
        usb_deregister(&adu_driver);
-       dbg(2," %s : leave", __FUNCTION__);
+       dbg(2," %s : leave", __func__);
 }
 
 module_init(adu_init);
index a5e4c35..a076c24 100644 (file)
@@ -103,11 +103,11 @@ static void appledisplay_complete(struct urb *urb)
        case -ESHUTDOWN:
                /* This urb is terminated, clean up */
                dbg("%s - urb shuttingdown with status: %d",
-                       __FUNCTION__, status);
+                       __func__, status);
                return;
        default:
                dbg("%s - nonzero urb status received: %d",
-                       __FUNCTION__, status);
+                       __func__, status);
                goto exit;
        }
 
@@ -131,7 +131,7 @@ exit:
        retval = usb_submit_urb(pdata->urb, GFP_ATOMIC);
        if (retval) {
                err("%s - usb_submit_urb failed with result %d",
-                       __FUNCTION__, retval);
+                       __func__, retval);
        }
 }
 
index 81d051c..309c743 100644 (file)
@@ -983,7 +983,7 @@ static void auerswald_int_complete (struct urb * urb)
         pauerbuf_t   bp = NULL;
         pauerswald_t cp = (pauerswald_t) urb->context;
 
-        dbg ("%s called", __FUNCTION__);
+        dbg ("%s called", __func__);
 
        switch (status) {
        case 0:
@@ -993,10 +993,10 @@ static void auerswald_int_complete (struct urb * urb)
        case -ENOENT:
        case -ESHUTDOWN:
                /* this urb is terminated, clean up */
-               dbg("%s - urb shutting down with status: %d", __FUNCTION__, status);
+               dbg("%s - urb shutting down with status: %d", __func__, status);
                return;
        default:
-               dbg("%s - nonzero urb status received: %d", __FUNCTION__, status);
+               dbg("%s - nonzero urb status received: %d", __func__, status);
                goto exit;
        }
 
@@ -1081,7 +1081,7 @@ exit:
        ret = usb_submit_urb (urb, GFP_ATOMIC);
        if (ret)
                err ("%s - usb_submit_urb failed with result %d",
-                    __FUNCTION__, ret);
+                    __func__, ret);
 }
 
 /* int memory deallocation
index 4a09b87..4b9dc81 100644 (file)
@@ -70,8 +70,8 @@ static int emi26_writememory (struct usb_device *dev, int address, unsigned char
 static int emi26_set_reset (struct usb_device *dev, unsigned char reset_bit)
 {
        int response;
-       info("%s - %d", __FUNCTION__, reset_bit);
-       /* printk(KERN_DEBUG "%s - %d", __FUNCTION__, reset_bit); */
+       info("%s - %d", __func__, reset_bit);
+       /* printk(KERN_DEBUG "%s - %d", __func__, reset_bit); */
        response = emi26_writememory (dev, CPUCS_REG, &reset_bit, 1, 0xa0);
        if (response < 0) {
                err("emi26: set_reset (%d) failed", reset_bit);
@@ -91,7 +91,7 @@ static int emi26_load_firmware (struct usb_device *dev)
 
        buf = kmalloc(FW_LOAD_SIZE, GFP_KERNEL);
        if (!buf) {
-               err( "%s - error loading firmware: error = %d", __FUNCTION__, -ENOMEM);
+               err( "%s - error loading firmware: error = %d", __func__, -ENOMEM);
                err = -ENOMEM;
                goto wraperr;
        }
@@ -99,7 +99,7 @@ static int emi26_load_firmware (struct usb_device *dev)
        /* Assert reset (stop the CPU in the EMI) */
        err = emi26_set_reset(dev,1);
        if (err < 0) {
-               err( "%s - error loading firmware: error = %d", __FUNCTION__, err);
+               err( "%s - error loading firmware: error = %d", __func__, err);
                goto wraperr;
        }
 
@@ -107,7 +107,7 @@ static int emi26_load_firmware (struct usb_device *dev)
        for (i=0; g_Loader[i].type == 0; i++) {
                err = emi26_writememory(dev, g_Loader[i].address, g_Loader[i].data, g_Loader[i].length, ANCHOR_LOAD_INTERNAL);
                if (err < 0) {
-                       err("%s - error loading firmware: error = %d", __FUNCTION__, err);
+                       err("%s - error loading firmware: error = %d", __func__, err);
                        goto wraperr;
                }
        }
@@ -115,7 +115,7 @@ static int emi26_load_firmware (struct usb_device *dev)
        /* De-assert reset (let the CPU run) */
        err = emi26_set_reset(dev,0);
        if (err < 0) {
-               err("%s - error loading firmware: error = %d", __FUNCTION__, err);
+               err("%s - error loading firmware: error = %d", __func__, err);
                goto wraperr;
        }
        msleep(250);    /* let device settle */
@@ -135,7 +135,7 @@ static int emi26_load_firmware (struct usb_device *dev)
                }
                err = emi26_writememory(dev, addr, buf, i, ANCHOR_LOAD_FPGA);
                if (err < 0) {
-                       err("%s - error loading firmware: error = %d", __FUNCTION__, err);
+                       err("%s - error loading firmware: error = %d", __func__, err);
                        goto wraperr;
                }
        } while (i > 0);
@@ -143,7 +143,7 @@ static int emi26_load_firmware (struct usb_device *dev)
        /* Assert reset (stop the CPU in the EMI) */
        err = emi26_set_reset(dev,1);
        if (err < 0) {
-               err("%s - error loading firmware: error = %d", __FUNCTION__, err);
+               err("%s - error loading firmware: error = %d", __func__, err);
                goto wraperr;
        }
 
@@ -151,7 +151,7 @@ static int emi26_load_firmware (struct usb_device *dev)
        for (i=0; g_Loader[i].type == 0; i++) {
                err = emi26_writememory(dev, g_Loader[i].address, g_Loader[i].data, g_Loader[i].length, ANCHOR_LOAD_INTERNAL);
                if (err < 0) {
-                       err("%s - error loading firmware: error = %d", __FUNCTION__, err);
+                       err("%s - error loading firmware: error = %d", __func__, err);
                        goto wraperr;
                }
        }
@@ -160,7 +160,7 @@ static int emi26_load_firmware (struct usb_device *dev)
        /* De-assert reset (let the CPU run) */
        err = emi26_set_reset(dev,0);
        if (err < 0) {
-               err("%s - error loading firmware: error = %d", __FUNCTION__, err);
+               err("%s - error loading firmware: error = %d", __func__, err);
                goto wraperr;
        }
 
@@ -169,7 +169,7 @@ static int emi26_load_firmware (struct usb_device *dev)
                if (!INTERNAL_RAM(g_Firmware[i].address)) {
                        err = emi26_writememory(dev, g_Firmware[i].address, g_Firmware[i].data, g_Firmware[i].length, ANCHOR_LOAD_EXTERNAL);
                        if (err < 0) {
-                               err("%s - error loading firmware: error = %d", __FUNCTION__, err);
+                               err("%s - error loading firmware: error = %d", __func__, err);
                                goto wraperr;
                        }
                }
@@ -178,7 +178,7 @@ static int emi26_load_firmware (struct usb_device *dev)
        /* Assert reset (stop the CPU in the EMI) */
        err = emi26_set_reset(dev,1);
        if (err < 0) {
-               err("%s - error loading firmware: error = %d", __FUNCTION__, err);
+               err("%s - error loading firmware: error = %d", __func__, err);
                goto wraperr;
        }
 
@@ -186,7 +186,7 @@ static int emi26_load_firmware (struct usb_device *dev)
                if (INTERNAL_RAM(g_Firmware[i].address)) {
                        err = emi26_writememory(dev, g_Firmware[i].address, g_Firmware[i].data, g_Firmware[i].length, ANCHOR_LOAD_INTERNAL);
                        if (err < 0) {
-                               err("%s - error loading firmware: error = %d", __FUNCTION__, err);
+                               err("%s - error loading firmware: error = %d", __func__, err);
                                goto wraperr;
                        }
                }
@@ -195,7 +195,7 @@ static int emi26_load_firmware (struct usb_device *dev)
        /* De-assert reset (let the CPU run) */
        err = emi26_set_reset(dev,0);
        if (err < 0) {
-               err("%s - error loading firmware: error = %d", __FUNCTION__, err);
+               err("%s - error loading firmware: error = %d", __func__, err);
                goto wraperr;
        }
        msleep(250);    /* let device settle */
@@ -221,7 +221,7 @@ static int emi26_probe(struct usb_interface *intf, const struct usb_device_id *i
 {
        struct usb_device *dev = interface_to_usbdev(intf);
 
-       info("%s start", __FUNCTION__); 
+       info("%s start", __func__);
 
        emi26_load_firmware(dev);
 
index d136241..1a2b79a 100644 (file)
@@ -78,7 +78,7 @@ static int emi62_writememory (struct usb_device *dev, int address, unsigned char
 static int emi62_set_reset (struct usb_device *dev, unsigned char reset_bit)
 {
        int response;
-       info("%s - %d", __FUNCTION__, reset_bit);
+       info("%s - %d", __func__, reset_bit);
        
        response = emi62_writememory (dev, CPUCS_REG, &reset_bit, 1, 0xa0);
        if (response < 0) {
@@ -100,7 +100,7 @@ static int emi62_load_firmware (struct usb_device *dev)
        dev_dbg(&dev->dev, "load_firmware\n");
        buf = kmalloc(FW_LOAD_SIZE, GFP_KERNEL);
        if (!buf) {
-               err( "%s - error loading firmware: error = %d", __FUNCTION__, -ENOMEM);
+               err( "%s - error loading firmware: error = %d", __func__, -ENOMEM);
                err = -ENOMEM;
                goto wraperr;
        }
@@ -108,7 +108,7 @@ static int emi62_load_firmware (struct usb_device *dev)
        /* Assert reset (stop the CPU in the EMI) */
        err = emi62_set_reset(dev,1);
        if (err < 0) {
-               err("%s - error loading firmware: error = %d", __FUNCTION__, err);
+               err("%s - error loading firmware: error = %d", __func__, err);
                goto wraperr;
        }
 
@@ -116,7 +116,7 @@ static int emi62_load_firmware (struct usb_device *dev)
        for (i=0; g_emi62_loader[i].type == 0; i++) {
                err = emi62_writememory(dev, g_emi62_loader[i].address, g_emi62_loader[i].data, g_emi62_loader[i].length, ANCHOR_LOAD_INTERNAL);
                if (err < 0) {
-                       err("%s - error loading firmware: error = %d", __FUNCTION__, err);
+                       err("%s - error loading firmware: error = %d", __func__, err);
                        goto wraperr;
                }
        }
@@ -124,7 +124,7 @@ static int emi62_load_firmware (struct usb_device *dev)
        /* De-assert reset (let the CPU run) */
        err = emi62_set_reset(dev,0);
        if (err < 0) {
-               err("%s - error loading firmware: error = %d", __FUNCTION__, err);
+               err("%s - error loading firmware: error = %d", __func__, err);
                goto wraperr;
        }
        msleep(250);    /* let device settle */
@@ -144,7 +144,7 @@ static int emi62_load_firmware (struct usb_device *dev)
                }
                err = emi62_writememory(dev, addr, buf, i, ANCHOR_LOAD_FPGA);
                if (err < 0) {
-                       err("%s - error loading firmware: error = %d", __FUNCTION__, err);
+                       err("%s - error loading firmware: error = %d", __func__, err);
                        goto wraperr;
                }
        } while (i > 0);
@@ -152,7 +152,7 @@ static int emi62_load_firmware (struct usb_device *dev)
        /* Assert reset (stop the CPU in the EMI) */
        err = emi62_set_reset(dev,1);
        if (err < 0) {
-               err("%s - error loading firmware: error = %d", __FUNCTION__, err);
+               err("%s - error loading firmware: error = %d", __func__, err);
                goto wraperr;
        }
 
@@ -160,7 +160,7 @@ static int emi62_load_firmware (struct usb_device *dev)
        for (i=0; g_emi62_loader[i].type == 0; i++) {
                err = emi62_writememory(dev, g_emi62_loader[i].address, g_emi62_loader[i].data, g_emi62_loader[i].length, ANCHOR_LOAD_INTERNAL);
                if (err < 0) {
-                       err("%s - error loading firmware: error = %d", __FUNCTION__, err);
+                       err("%s - error loading firmware: error = %d", __func__, err);
                        goto wraperr;
                }
        }
@@ -168,7 +168,7 @@ static int emi62_load_firmware (struct usb_device *dev)
        /* De-assert reset (let the CPU run) */
        err = emi62_set_reset(dev,0);
        if (err < 0) {
-               err("%s - error loading firmware: error = %d", __FUNCTION__, err);
+               err("%s - error loading firmware: error = %d", __func__, err);
                goto wraperr;
        }
        msleep(250);    /* let device settle */
@@ -181,7 +181,7 @@ static int emi62_load_firmware (struct usb_device *dev)
                if (!INTERNAL_RAM(g_HexSpdifFw62[i].address)) {
                        err = emi62_writememory(dev, g_HexSpdifFw62[i].address, g_HexSpdifFw62[i].data, g_HexSpdifFw62[i].length, ANCHOR_LOAD_EXTERNAL);
                        if (err < 0) {
-                               err("%s - error loading firmware: error = %d", __FUNCTION__, err);
+                               err("%s - error loading firmware: error = %d", __func__, err);
                                goto wraperr;
                        }
                }
@@ -191,7 +191,7 @@ static int emi62_load_firmware (struct usb_device *dev)
                if (!INTERNAL_RAM(g_HexMidiFw62[i].address)) {
                        err = emi62_writememory(dev, g_HexMidiFw62[i].address, g_HexMidiFw62[i].data, g_HexMidiFw62[i].length, ANCHOR_LOAD_EXTERNAL);
                        if (err < 0) {
-                               err("%s - error loading firmware: error = %d\n", __FUNCTION__, err);
+                               err("%s - error loading firmware: error = %d\n", __func__, err);
                                goto wraperr;
                                return err;
                        }
@@ -201,7 +201,7 @@ static int emi62_load_firmware (struct usb_device *dev)
        /* Assert reset (stop the CPU in the EMI) */
        err = emi62_set_reset(dev,1);
        if (err < 0) {
-               err("%s - error loading firmware: error = %d", __FUNCTION__, err);
+               err("%s - error loading firmware: error = %d", __func__, err);
                goto wraperr;
        }
 
@@ -211,7 +211,7 @@ static int emi62_load_firmware (struct usb_device *dev)
                if (INTERNAL_RAM(g_HexSpdifFw62[i].address)) {
                        err = emi62_writememory(dev, g_HexSpdifFw62[i].address, g_HexSpdifFw62[i].data, g_HexSpdifFw62[i].length, ANCHOR_LOAD_INTERNAL);
                        if (err < 0) {
-                               err("%s - error loading firmware: error = %d", __FUNCTION__, err);
+                               err("%s - error loading firmware: error = %d", __func__, err);
                                goto wraperr;
                        }
                }
@@ -221,7 +221,7 @@ static int emi62_load_firmware (struct usb_device *dev)
                if (INTERNAL_RAM(g_HexMidiFw62[i].address)) {
                        err = emi62_writememory(dev, g_HexMidiFw62[i].address, g_HexMidiFw62[i].data, g_HexMidiFw62[i].length, ANCHOR_LOAD_INTERNAL);
                        if (err < 0) {
-                               err("%s - error loading firmware: error = %d\n", __FUNCTION__, err);
+                               err("%s - error loading firmware: error = %d\n", __func__, err);
                                goto wraperr;
                        }
                }
@@ -231,7 +231,7 @@ static int emi62_load_firmware (struct usb_device *dev)
        /* De-assert reset (let the CPU run) */
        err = emi62_set_reset(dev,0);
        if (err < 0) {
-               err("%s - error loading firmware: error = %d", __FUNCTION__, err);
+               err("%s - error loading firmware: error = %d", __func__, err);
                goto wraperr;
        }
        msleep(250);    /* let device settle */
@@ -260,7 +260,7 @@ static int emi62_probe(struct usb_interface *intf, const struct usb_device_id *i
        struct usb_device *dev = interface_to_usbdev(intf);
        dev_dbg(&intf->dev, "emi62_probe\n");
 
-       info("%s start", __FUNCTION__); 
+       info("%s start", __func__);
 
        emi62_load_firmware(dev);
 
index 8010705..0a2549b 100644 (file)
@@ -218,7 +218,7 @@ exit:
        retval = usb_submit_urb(urb, GFP_ATOMIC);
        if (retval)
                dev_err(&dev->interface->dev, "%s - usb_submit_urb failed with result %d\n",
-                       __FUNCTION__, retval);
+                       __func__, retval);
 
 }
 
@@ -453,7 +453,7 @@ static ssize_t iowarrior_write(struct file *file,
        default:
                /* what do we have here ? An unsupported Product-ID ? */
                dev_err(&dev->interface->dev, "%s - not supported for product=0x%x\n",
-                       __FUNCTION__, dev->product_id);
+                       __func__, dev->product_id);
                retval = -EFAULT;
                goto exit;
                break;
@@ -604,7 +604,7 @@ static int iowarrior_open(struct inode *inode, struct file *file)
 
        interface = usb_find_interface(&iowarrior_driver, subminor);
        if (!interface) {
-               err("%s - error, can't find device for minor %d", __FUNCTION__,
+               err("%s - error, can't find device for minor %d", __func__,
                    subminor);
                return -ENODEV;
        }
index c730d20..11580e8 100644 (file)
@@ -231,7 +231,7 @@ static void ld_usb_interrupt_in_callback(struct urb *urb)
                        goto exit;
                } else {
                        dbg_info(&dev->intf->dev, "%s: nonzero status received: %d\n",
-                                __FUNCTION__, status);
+                                __func__, status);
                        spin_lock(&dev->rbsl);
                        goto resubmit; /* maybe we can recover */
                }
@@ -247,7 +247,7 @@ static void ld_usb_interrupt_in_callback(struct urb *urb)
                        memcpy(actual_buffer+1, dev->interrupt_in_buffer, urb->actual_length);
                        dev->ring_head = next_ring_head;
                        dbg_info(&dev->intf->dev, "%s: received %d bytes\n",
-                                __FUNCTION__, urb->actual_length);
+                                __func__, urb->actual_length);
                } else {
                        dev_warn(&dev->intf->dev,
                                 "Ring buffer overflow, %d bytes dropped\n",
@@ -286,7 +286,7 @@ static void ld_usb_interrupt_out_callback(struct urb *urb)
                        status == -ESHUTDOWN))
                dbg_info(&dev->intf->dev,
                         "%s - nonzero write interrupt status received: %d\n",
-                        __FUNCTION__, status);
+                        __func__, status);
 
        dev->interrupt_out_busy = 0;
        wake_up_interruptible(&dev->write_wait);
@@ -309,7 +309,7 @@ static int ld_usb_open(struct inode *inode, struct file *file)
 
        if (!interface) {
                err("%s - error, can't find device for minor %d\n",
-                    __FUNCTION__, subminor);
+                    __func__, subminor);
                return -ENODEV;
        }
 
@@ -556,7 +556,7 @@ static ssize_t ld_usb_write(struct file *file, const char __user *buffer,
        bytes_to_write = min(count, write_buffer_size*dev->interrupt_out_endpoint_size);
        if (bytes_to_write < count)
                dev_warn(&dev->intf->dev, "Write buffer overflow, %zd bytes dropped\n",count-bytes_to_write);
-       dbg_info(&dev->intf->dev, "%s: count = %zd, bytes_to_write = %zd\n", __FUNCTION__, count, bytes_to_write);
+       dbg_info(&dev->intf->dev, "%s: count = %zd, bytes_to_write = %zd\n", __func__, count, bytes_to_write);
 
        if (copy_from_user(dev->interrupt_out_buffer, buffer, bytes_to_write)) {
                retval = -EFAULT;
index 6664043..fae5b17 100644 (file)
@@ -31,7 +31,7 @@
  *   - imported into lejos project
  *   - changed wake_up to wake_up_interruptible
  *   - changed to use lego0 rather than tower0
- *   - changed dbg() to use __func__ rather than deprecated __FUNCTION__
+ *   - changed dbg() to use __func__ rather than deprecated __func__
  * 2003-01-12 - 0.53 david (david@csse.uwa.edu.au)
  *   - changed read and write to write everything or
  *     timeout (from a patch by Chris Riesen and Brett Thaeler driver)
@@ -49,7 +49,7 @@
  *   - added poll
  *   - forbid seeking
  *   - added nonblocking I/O
- *   - changed back __func__ to __FUNCTION__
+ *   - changed back __func__ to __func__
  *   - read and log tower firmware version
  *   - reset tower on probe, avoids failure of first write
  * 2004-03-09 - 0.7 Juergen Stuber <starblue@users.sourceforge.net>
@@ -309,7 +309,7 @@ static inline void lego_usb_tower_debug_data (int level, const char *function, i
  */
 static inline void tower_delete (struct lego_usb_tower *dev)
 {
-       dbg(2, "%s: enter", __FUNCTION__);
+       dbg(2, "%s: enter", __func__);
 
        tower_abort_transfers (dev);
 
@@ -321,7 +321,7 @@ static inline void tower_delete (struct lego_usb_tower *dev)
        kfree (dev->interrupt_out_buffer);
        kfree (dev);
 
-       dbg(2, "%s: leave", __FUNCTION__);
+       dbg(2, "%s: leave", __func__);
 }
 
 
@@ -337,7 +337,7 @@ static int tower_open (struct inode *inode, struct file *file)
        struct tower_reset_reply reset_reply;
        int result;
 
-       dbg(2, "%s: enter", __FUNCTION__);
+       dbg(2, "%s: enter", __func__);
 
        nonseekable_open(inode, file);
        subminor = iminor(inode);
@@ -346,7 +346,7 @@ static int tower_open (struct inode *inode, struct file *file)
 
        if (!interface) {
                err ("%s - error, can't find device for minor %d",
-                    __FUNCTION__, subminor);
+                    __func__, subminor);
                retval = -ENODEV;
                goto exit;
        }
@@ -424,7 +424,7 @@ unlock_exit:
        mutex_unlock(&dev->lock);
 
 exit:
-       dbg(2, "%s: leave, return value %d ", __FUNCTION__, retval);
+       dbg(2, "%s: leave, return value %d ", __func__, retval);
 
        return retval;
 }
@@ -437,12 +437,12 @@ static int tower_release (struct inode *inode, struct file *file)
        struct lego_usb_tower *dev;
        int retval = 0;
 
-       dbg(2, "%s: enter", __FUNCTION__);
+       dbg(2, "%s: enter", __func__);
 
        dev = (struct lego_usb_tower *)file->private_data;
 
        if (dev == NULL) {
-               dbg(1, "%s: object is NULL", __FUNCTION__);
+               dbg(1, "%s: object is NULL", __func__);
                retval = -ENODEV;
                goto exit_nolock;
        }
@@ -454,7 +454,7 @@ static int tower_release (struct inode *inode, struct file *file)
        }
 
        if (dev->open_count != 1) {
-               dbg(1, "%s: device not opened exactly once", __FUNCTION__);
+               dbg(1, "%s: device not opened exactly once", __func__);
                retval = -ENODEV;
                goto unlock_exit;
        }
@@ -480,7 +480,7 @@ unlock_exit:
 exit:
        mutex_unlock(&open_disc_mutex);
 exit_nolock:
-       dbg(2, "%s: leave, return value %d", __FUNCTION__, retval);
+       dbg(2, "%s: leave, return value %d", __func__, retval);
        return retval;
 }
 
@@ -491,10 +491,10 @@ exit_nolock:
  */
 static void tower_abort_transfers (struct lego_usb_tower *dev)
 {
-       dbg(2, "%s: enter", __FUNCTION__);
+       dbg(2, "%s: enter", __func__);
 
        if (dev == NULL) {
-               dbg(1, "%s: dev is null", __FUNCTION__);
+               dbg(1, "%s: dev is null", __func__);
                goto exit;
        }
 
@@ -509,7 +509,7 @@ static void tower_abort_transfers (struct lego_usb_tower *dev)
                usb_kill_urb(dev->interrupt_out_urb);
 
 exit:
-       dbg(2, "%s: leave", __FUNCTION__);
+       dbg(2, "%s: leave", __func__);
 }
 
 
@@ -542,7 +542,7 @@ static unsigned int tower_poll (struct file *file, poll_table *wait)
        struct lego_usb_tower *dev;
        unsigned int mask = 0;
 
-       dbg(2, "%s: enter", __FUNCTION__);
+       dbg(2, "%s: enter", __func__);
 
        dev = file->private_data;
 
@@ -557,7 +557,7 @@ static unsigned int tower_poll (struct file *file, poll_table *wait)
                mask |= POLLOUT | POLLWRNORM;
        }
 
-       dbg(2, "%s: leave, mask = %d", __FUNCTION__, mask);
+       dbg(2, "%s: leave, mask = %d", __func__, mask);
 
        return mask;
 }
@@ -583,7 +583,7 @@ static ssize_t tower_read (struct file *file, char __user *buffer, size_t count,
        int retval = 0;
        unsigned long timeout = 0;
 
-       dbg(2, "%s: enter, count = %Zd", __FUNCTION__, count);
+       dbg(2, "%s: enter, count = %Zd", __func__, count);
 
        dev = (struct lego_usb_tower *)file->private_data;
 
@@ -602,7 +602,7 @@ static ssize_t tower_read (struct file *file, char __user *buffer, size_t count,
 
        /* verify that we actually have some data to read */
        if (count == 0) {
-               dbg(1, "%s: read request of 0 bytes", __FUNCTION__);
+               dbg(1, "%s: read request of 0 bytes", __func__);
                goto unlock_exit;
        }
 
@@ -658,7 +658,7 @@ unlock_exit:
        mutex_unlock(&dev->lock);
 
 exit:
-       dbg(2, "%s: leave, return value %d", __FUNCTION__, retval);
+       dbg(2, "%s: leave, return value %d", __func__, retval);
        return retval;
 }
 
@@ -672,7 +672,7 @@ static ssize_t tower_write (struct file *file, const char __user *buffer, size_t
        size_t bytes_to_write;
        int retval = 0;
 
-       dbg(2, "%s: enter, count = %Zd", __FUNCTION__, count);
+       dbg(2, "%s: enter, count = %Zd", __func__, count);
 
        dev = (struct lego_usb_tower *)file->private_data;
 
@@ -691,7 +691,7 @@ static ssize_t tower_write (struct file *file, const char __user *buffer, size_t
 
        /* verify that we actually have some data to write */
        if (count == 0) {
-               dbg(1, "%s: write request of 0 bytes", __FUNCTION__);
+               dbg(1, "%s: write request of 0 bytes", __func__);
                goto unlock_exit;
        }
 
@@ -709,7 +709,7 @@ static ssize_t tower_write (struct file *file, const char __user *buffer, size_t
 
        /* write the data into interrupt_out_buffer from userspace */
        bytes_to_write = min_t(int, count, write_buffer_size);
-       dbg(4, "%s: count = %Zd, bytes_to_write = %Zd", __FUNCTION__, count, bytes_to_write);
+       dbg(4, "%s: count = %Zd, bytes_to_write = %Zd", __func__, count, bytes_to_write);
 
        if (copy_from_user (dev->interrupt_out_buffer, buffer, bytes_to_write)) {
                retval = -EFAULT;
@@ -742,7 +742,7 @@ unlock_exit:
        mutex_unlock(&dev->lock);
 
 exit:
-       dbg(2, "%s: leave, return value %d", __FUNCTION__, retval);
+       dbg(2, "%s: leave, return value %d", __func__, retval);
 
        return retval;
 }
@@ -757,9 +757,9 @@ static void tower_interrupt_in_callback (struct urb *urb)
        int status = urb->status;
        int retval;
 
-       dbg(4, "%s: enter, status %d", __FUNCTION__, status);
+       dbg(4, "%s: enter, status %d", __func__, status);
 
-       lego_usb_tower_debug_data(5, __FUNCTION__, urb->actual_length, urb->transfer_buffer);
+       lego_usb_tower_debug_data(5, __func__, urb->actual_length, urb->transfer_buffer);
 
        if (status) {
                if (status == -ENOENT ||
@@ -767,7 +767,7 @@ static void tower_interrupt_in_callback (struct urb *urb)
                    status == -ESHUTDOWN) {
                        goto exit;
                } else {
-                       dbg(1, "%s: nonzero status received: %d", __FUNCTION__, status);
+                       dbg(1, "%s: nonzero status received: %d", __func__, status);
                        goto resubmit; /* maybe we can recover */
                }
        }
@@ -780,9 +780,9 @@ static void tower_interrupt_in_callback (struct urb *urb)
                                urb->actual_length);
                        dev->read_buffer_length += urb->actual_length;
                        dev->read_last_arrival = jiffies;
-                       dbg(3, "%s: received %d bytes", __FUNCTION__, urb->actual_length);
+                       dbg(3, "%s: received %d bytes", __func__, urb->actual_length);
                } else {
-                       printk(KERN_WARNING "%s: read_buffer overflow, %d bytes dropped", __FUNCTION__, urb->actual_length);
+                       printk(KERN_WARNING "%s: read_buffer overflow, %d bytes dropped", __func__, urb->actual_length);
                }
                spin_unlock (&dev->read_buffer_lock);
        }
@@ -792,7 +792,7 @@ resubmit:
        if (dev->interrupt_in_running && dev->udev) {
                retval = usb_submit_urb (dev->interrupt_in_urb, GFP_ATOMIC);
                if (retval) {
-                       err("%s: usb_submit_urb failed (%d)", __FUNCTION__, retval);
+                       err("%s: usb_submit_urb failed (%d)", __func__, retval);
                }
        }
 
@@ -800,8 +800,8 @@ exit:
        dev->interrupt_in_done = 1;
        wake_up_interruptible (&dev->read_wait);
 
-       lego_usb_tower_debug_data(5, __FUNCTION__, urb->actual_length, urb->transfer_buffer);
-       dbg(4, "%s: leave, status %d", __FUNCTION__, status);
+       lego_usb_tower_debug_data(5, __func__, urb->actual_length, urb->transfer_buffer);
+       dbg(4, "%s: leave, status %d", __func__, status);
 }
 
 
@@ -813,22 +813,22 @@ static void tower_interrupt_out_callback (struct urb *urb)
        struct lego_usb_tower *dev = (struct lego_usb_tower *)urb->context;
        int status = urb->status;
 
-       dbg(4, "%s: enter, status %d", __FUNCTION__, status);
-       lego_usb_tower_debug_data(5, __FUNCTION__, urb->actual_length, urb->transfer_buffer);
+       dbg(4, "%s: enter, status %d", __func__, status);
+       lego_usb_tower_debug_data(5, __func__, urb->actual_length, urb->transfer_buffer);
 
        /* sync/async unlink faults aren't errors */
        if (status && !(status == -ENOENT ||
                        status == -ECONNRESET ||
                        status == -ESHUTDOWN)) {
                dbg(1, "%s - nonzero write bulk status received: %d",
-                   __FUNCTION__, status);
+                   __func__, status);
        }
 
        dev->interrupt_out_busy = 0;
        wake_up_interruptible(&dev->write_wait);
 
-       lego_usb_tower_debug_data(5, __FUNCTION__, urb->actual_length, urb->transfer_buffer);
-       dbg(4, "%s: leave, status %d", __FUNCTION__, status);
+       lego_usb_tower_debug_data(5, __func__, urb->actual_length, urb->transfer_buffer);
+       dbg(4, "%s: leave, status %d", __func__, status);
 }
 
 
@@ -849,7 +849,7 @@ static int tower_probe (struct usb_interface *interface, const struct usb_device
        int retval = -ENOMEM;
        int result;
 
-       dbg(2, "%s: enter", __FUNCTION__);
+       dbg(2, "%s: enter", __func__);
 
        if (udev == NULL) {
                info ("udev is NULL.");
@@ -978,7 +978,7 @@ static int tower_probe (struct usb_interface *interface, const struct usb_device
 
 
 exit:
-       dbg(2, "%s: leave, return value 0x%.8lx (dev)", __FUNCTION__, (long) dev);
+       dbg(2, "%s: leave, return value 0x%.8lx (dev)", __func__, (long) dev);
 
        return retval;
 
@@ -998,7 +998,7 @@ static void tower_disconnect (struct usb_interface *interface)
        struct lego_usb_tower *dev;
        int minor;
 
-       dbg(2, "%s: enter", __FUNCTION__);
+       dbg(2, "%s: enter", __func__);
 
        dev = usb_get_intfdata (interface);
        mutex_lock(&open_disc_mutex);
@@ -1023,7 +1023,7 @@ static void tower_disconnect (struct usb_interface *interface)
 
        info("LEGO USB Tower #%d now disconnected", (minor - LEGO_USB_TOWER_MINOR_BASE));
 
-       dbg(2, "%s: leave", __FUNCTION__);
+       dbg(2, "%s: leave", __func__);
 }
 
 
@@ -1036,7 +1036,7 @@ static int __init lego_usb_tower_init(void)
        int result;
        int retval = 0;
 
-       dbg(2, "%s: enter", __FUNCTION__);
+       dbg(2, "%s: enter", __func__);
 
        /* register this driver with the USB subsystem */
        result = usb_register(&tower_driver);
@@ -1049,7 +1049,7 @@ static int __init lego_usb_tower_init(void)
        info(DRIVER_DESC " " DRIVER_VERSION);
 
 exit:
-       dbg(2, "%s: leave, return value %d", __FUNCTION__, retval);
+       dbg(2, "%s: leave, return value %d", __func__, retval);
 
        return retval;
 }
@@ -1060,12 +1060,12 @@ exit:
  */
 static void __exit lego_usb_tower_exit(void)
 {
-       dbg(2, "%s: enter", __FUNCTION__);
+       dbg(2, "%s: enter", __func__);
 
        /* deregister this driver with the USB subsystem */
        usb_deregister (&tower_driver);
 
-       dbg(2, "%s: leave", __FUNCTION__);
+       dbg(2, "%s: leave", __func__);
 }
 
 module_init (lego_usb_tower_init);
index aa9bcce..24230c6 100644 (file)
@@ -113,7 +113,7 @@ static int set_outputs(struct interfacekit *kit)
 
        buffer = kzalloc(4, GFP_KERNEL);
        if (!buffer) {
-               dev_err(&kit->udev->dev, "%s - out of memory\n", __FUNCTION__);
+               dev_err(&kit->udev->dev, "%s - out of memory\n", __func__);
                return -ENOMEM;
        }
        buffer[0] = (u8)kit->outputs;
@@ -146,7 +146,7 @@ static int change_string(struct interfacekit *kit, const char *display, unsigned
        buffer = kmalloc(8, GFP_KERNEL);
        form_buffer = kmalloc(30, GFP_KERNEL);
        if ((!buffer) || (!form_buffer)) {
-               dev_err(&kit->udev->dev, "%s - out of memory\n", __FUNCTION__);
+               dev_err(&kit->udev->dev, "%s - out of memory\n", __func__);
                goto exit;
        }
 
@@ -216,7 +216,7 @@ static ssize_t set_backlight(struct device *dev, struct device_attribute *attr,
        
        buffer = kzalloc(8, GFP_KERNEL);
        if (!buffer) {
-               dev_err(&kit->udev->dev, "%s - out of memory\n", __FUNCTION__);
+               dev_err(&kit->udev->dev, "%s - out of memory\n", __func__);
                goto exit;
        }
 
index 2ad09b1..f0113c1 100644 (file)
@@ -61,7 +61,7 @@ static int set_motor(struct motorcontrol *mc, int motor)
 
        buffer = kzalloc(8, GFP_KERNEL);
        if (!buffer) {
-               dev_err(&mc->intf->dev, "%s - out of memory\n", __FUNCTION__);
+               dev_err(&mc->intf->dev, "%s - out of memory\n", __func__);
                return -ENOMEM;
        }
 
index 0d9de2f..7d590c0 100644 (file)
@@ -89,7 +89,7 @@ change_position_v30(struct phidget_servo *servo, int servo_no, int degrees,
        buffer = kmalloc(6, GFP_KERNEL);
        if (!buffer) {
                dev_err(&servo->udev->dev, "%s - out of memory\n",
-                       __FUNCTION__);
+                       __func__);
                return -ENOMEM;
        }
 
@@ -162,7 +162,7 @@ change_position_v20(struct phidget_servo *servo, int servo_no, int degrees,
        buffer = kmalloc(2, GFP_KERNEL);
        if (!buffer) {
                dev_err(&servo->udev->dev, "%s - out of memory\n",
-                       __FUNCTION__);
+                       __func__);
                return -ENOMEM;
        }
 
@@ -259,7 +259,7 @@ servo_probe(struct usb_interface *interface, const struct usb_device_id *id)
 
        dev = kzalloc(sizeof (struct phidget_servo), GFP_KERNEL);
        if (dev == NULL) {
-               dev_err(&interface->dev, "%s - out of memory\n", __FUNCTION__);
+               dev_err(&interface->dev, "%s - out of memory\n", __func__);
                rc = -ENOMEM;
                goto out;
        }
index 20777d0..ada7bf8 100644 (file)
@@ -78,7 +78,7 @@ static int lcd_open(struct inode *inode, struct file *file)
        interface = usb_find_interface(&lcd_driver, subminor);
        if (!interface) {
                err ("USBLCD: %s - error, can't find device for minor %d",
-                    __FUNCTION__, subminor);
+                    __func__, subminor);
                return -ENODEV;
        }
 
@@ -193,7 +193,7 @@ static void lcd_write_bulk_callback(struct urb *urb)
              status == -ECONNRESET ||
               status == -ESHUTDOWN)) {
                dbg("USBLCD: %s - nonzero write bulk status received: %d",
-                   __FUNCTION__, status);
+                   __func__, status);
        }
 
        /* free up our allocated buffer */
@@ -248,7 +248,7 @@ static ssize_t lcd_write(struct file *file, const char __user * user_buffer, siz
        /* send the data out the bulk port */
        retval = usb_submit_urb(urb, GFP_KERNEL);
        if (retval) {
-               err("USBLCD: %s - failed submitting write urb, error %d", __FUNCTION__, retval);
+               err("USBLCD: %s - failed submitting write urb, error %d", __func__, retval);
                goto error_unanchor;
        }
        
index 2c4fd4d..678fac8 100644 (file)
@@ -1136,7 +1136,7 @@ static int verify_not_halted (int ep, struct urb *urb)
                dbg ("ep %02x bogus status: %04x != 0", ep, status);
                return -EINVAL;
        }
-       retval = simple_io (urb, 1, 0, 0, __FUNCTION__);
+       retval = simple_io (urb, 1, 0, 0, __func__);
        if (retval != 0)
                return -EINVAL;
        return 0;
@@ -1158,7 +1158,7 @@ static int verify_halted (int ep, struct urb *urb)
                dbg ("ep %02x bogus status: %04x != 1", ep, status);
                return -EINVAL;
        }
-       retval = simple_io (urb, 1, 0, -EPIPE, __FUNCTION__);
+       retval = simple_io (urb, 1, 0, -EPIPE, __func__);
        if (retval != -EPIPE)
                return -EINVAL;
        retval = simple_io (urb, 1, 0, -EPIPE, "verify_still_halted");
index 1cd29cd..a238817 100644 (file)
@@ -210,7 +210,7 @@ static void aircable_send(struct usb_serial_port *port)
        struct aircable_private *priv = usb_get_serial_port_data(port);
        unsigned char* buf;
        u16 *dbuf;
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
        if (port->write_urb_busy)
                return;
 
@@ -220,7 +220,7 @@ static void aircable_send(struct usb_serial_port *port)
 
        buf = kzalloc(count + HCI_HEADER_LENGTH, GFP_ATOMIC);
        if (!buf) {
-               err("%s- kzalloc(%d) failed.", __FUNCTION__,
+               err("%s- kzalloc(%d) failed.", __func__,
                    count + HCI_HEADER_LENGTH);
                return;
        }
@@ -236,7 +236,7 @@ static void aircable_send(struct usb_serial_port *port)
 
        kfree(buf);
        port->write_urb_busy = 1;
-       usb_serial_debug_data(debug, &port->dev, __FUNCTION__,
+       usb_serial_debug_data(debug, &port->dev, __func__,
                              count + HCI_HEADER_LENGTH,
                              port->write_urb->transfer_buffer);
        port->write_urb->transfer_buffer_length = count + HCI_HEADER_LENGTH;
@@ -246,7 +246,7 @@ static void aircable_send(struct usb_serial_port *port)
        if (result) {
                dev_err(&port->dev,
                        "%s - failed submitting write urb, error %d\n",
-                       __FUNCTION__, result);
+                       __func__, result);
                port->write_urb_busy = 0;
        }
 
@@ -275,7 +275,7 @@ static void aircable_read(struct work_struct *work)
 
        if (!tty) {
                schedule_work(&priv->rx_work);
-               err("%s - No tty available", __FUNCTION__);
+               err("%s - No tty available", __func__);
                return ;
        }
 
@@ -286,7 +286,7 @@ static void aircable_read(struct work_struct *work)
 
        tty_prepare_flip_string(tty, &data, count);
        if (!data){
-               err("%s- kzalloc(%d) failed.", __FUNCTION__, count);
+               err("%s- kzalloc(%d) failed.", __func__, count);
                return;
        }
 
@@ -332,7 +332,7 @@ static int aircable_attach (struct usb_serial *serial)
 
        priv = kzalloc(sizeof(struct aircable_private), GFP_KERNEL);
        if (!priv){
-               err("%s- kmalloc(%Zd) failed.", __FUNCTION__,
+               err("%s- kmalloc(%Zd) failed.", __func__,
                        sizeof(struct aircable_private));
                return -ENOMEM;
        }
@@ -366,7 +366,7 @@ static void aircable_shutdown(struct usb_serial *serial)
        struct usb_serial_port *port = serial->port[0];
        struct aircable_private *priv = usb_get_serial_port_data(port);
 
-       dbg("%s", __FUNCTION__);
+       dbg("%s", __func__);
 
        if (priv) {
                serial_buf_free(priv->tx_buf);
@@ -388,12 +388,12 @@ static int aircable_write(struct usb_serial_port *port,
        struct aircable_private *priv = usb_get_serial_port_data(port);
        int temp;
 
-       dbg("%s - port %d, %d bytes", __FUNCTION__, port->number, count);
+       dbg("%s - port %d, %d bytes", __func__, port->number, count);
 
-       usb_serial_debug_data(debug, &port->dev, __FUNCTION__, count, source);
+       usb_serial_debug_data(debug, &port->dev, __func__, count, source);
 
        if (!count){
-               dbg("%s - write request of 0 bytes", __FUNCTION__);
+               dbg("%s - write request of 0 bytes", __func__);
                return count;
        }
 
@@ -414,7 +414,7 @@ static void aircable_write_bulk_callback(struct urb *urb)
        int status = urb->status;
        int result;
 
-       dbg("%s - urb status: %d", __FUNCTION__ , status);
+       dbg("%s - urb status: %d", __func__ , status);
 
        /* This has been taken from cypress_m8.c cypress_write_int_callback */
        switch (status) {
@@ -426,21 +426,21 @@ static void aircable_write_bulk_callback(struct urb *urb)
                case -ESHUTDOWN:
                        /* this urb is terminated, clean up */
                        dbg("%s - urb shutting down with status: %d",
-                           __FUNCTION__, status);
+                           __func__, status);
                        port->write_urb_busy = 0;
                        return;
                default:
                        /* error in the urb, so we have to resubmit it */
-                       dbg("%s - Overflow in write", __FUNCTION__);
+                       dbg("%s - Overflow in write", __func__);
                        dbg("%s - nonzero write bulk status received: %d",
-                           __FUNCTION__, status);
+                           __func__, status);
                        port->write_urb->transfer_buffer_length = 1;
                        port->write_urb->dev = port->serial->dev;
                        result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
                        if (result)
                                dev_err(&urb->dev->dev,
                                        "%s - failed resubmitting write urb, error %d\n",
-                                       __FUNCTION__, result);
+                                       __func__, result);
                        else
                                return;
        }
@@ -460,17 +460,17 @@ static void aircable_read_bulk_callback(struct urb *urb)
        unsigned char *temp;
        int status = urb->status;
 
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
 
        if (status) {
-               dbg("%s - urb status = %d", __FUNCTION__, status);
+               dbg("%s - urb status = %d", __func__, status);
                if (!port->open_count) {
-                       dbg("%s - port is closed, exiting.", __FUNCTION__);
+                       dbg("%s - port is closed, exiting.", __func__);
                        return;
                }
                if (status == -EPROTO) {
                        dbg("%s - caught -EPROTO, resubmitting the urb",
-                           __FUNCTION__);
+                           __func__);
                        usb_fill_bulk_urb(port->read_urb, port->serial->dev,
                                          usb_rcvbulkpipe(port->serial->dev,
                                                          port->bulk_in_endpointAddress),
@@ -482,14 +482,14 @@ static void aircable_read_bulk_callback(struct urb *urb)
                        if (result)
                                dev_err(&urb->dev->dev,
                                        "%s - failed resubmitting read urb, error %d\n",
-                                       __FUNCTION__, result);
+                                       __func__, result);
                        return;
                }
-               dbg("%s - unable to handle the error, exiting.", __FUNCTION__);
+               dbg("%s - unable to handle the error, exiting.", __func__);
                return;
        }
 
-       usb_serial_debug_data(debug, &port->dev, __FUNCTION__,
+       usb_serial_debug_data(debug, &port->dev, __func__,
                                urb->actual_length,urb->transfer_buffer);
 
        tty = port->tty;
@@ -538,7 +538,7 @@ static void aircable_read_bulk_callback(struct urb *urb)
                if (result)
                        dev_err(&urb->dev->dev,
                                "%s - failed resubmitting read urb, error %d\n",
-                               __FUNCTION__, result);
+                               __func__, result);
        }
 
        return;
@@ -550,7 +550,7 @@ static void aircable_throttle(struct usb_serial_port *port)
        struct aircable_private *priv = usb_get_serial_port_data(port);
        unsigned long flags;
 
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
 
        spin_lock_irqsave(&priv->rx_lock, flags);
        priv->rx_flags |= THROTTLED;
@@ -564,7 +564,7 @@ static void aircable_unthrottle(struct usb_serial_port *port)
        int actually_throttled;
        unsigned long flags;
 
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
 
        spin_lock_irqsave(&priv->rx_lock, flags);
        actually_throttled = priv->rx_flags & ACTUALLY_THROTTLED;
index d5bcb37..725b6b9 100644 (file)
@@ -53,7 +53,7 @@ static int airprime_send_setup(struct usb_serial_port *port)
        struct usb_serial *serial = port->serial;
        struct airprime_private *priv;
 
-       dbg("%s", __FUNCTION__);
+       dbg("%s", __func__);
 
        if (port->number != 0)
                return 0;
@@ -83,14 +83,14 @@ static void airprime_read_bulk_callback(struct urb *urb)
        int result;
        int status = urb->status;
 
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
 
        if (status) {
                dbg("%s - nonzero read bulk status received: %d",
-                   __FUNCTION__, status);
+                   __func__, status);
                return;
        }
-       usb_serial_debug_data(debug, &port->dev, __FUNCTION__, urb->actual_length, data);
+       usb_serial_debug_data(debug, &port->dev, __func__, urb->actual_length, data);
 
        tty = port->tty;
        if (tty && urb->actual_length) {
@@ -101,7 +101,7 @@ static void airprime_read_bulk_callback(struct urb *urb)
        result = usb_submit_urb (urb, GFP_ATOMIC);
        if (result)
                dev_err(&port->dev, "%s - failed resubmitting read urb, error %d\n",
-                       __FUNCTION__, result);
+                       __func__, result);
        return;
 }
 
@@ -112,14 +112,14 @@ static void airprime_write_bulk_callback(struct urb *urb)
        int status = urb->status;
        unsigned long flags;
 
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
 
        /* free up the transfer buffer, as usb_free_urb() does not do this */
        kfree (urb->transfer_buffer);
 
        if (status)
                dbg("%s - nonzero write bulk status received: %d",
-                   __FUNCTION__, status);
+                   __func__, status);
        spin_lock_irqsave(&priv->lock, flags);
        --priv->outstanding_urbs;
        spin_unlock_irqrestore(&priv->lock, flags);
@@ -136,7 +136,7 @@ static int airprime_open(struct usb_serial_port *port, struct file *filp)
        int i;
        int result = 0;
 
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
 
        /* initialize our private data structure if it isn't already created */
        if (!priv) {
@@ -157,7 +157,7 @@ static int airprime_open(struct usb_serial_port *port, struct file *filp)
                buffer = kmalloc(buffer_size, GFP_KERNEL);
                if (!buffer) {
                        dev_err(&port->dev, "%s - out of memory.\n",
-                               __FUNCTION__);
+                               __func__);
                        result = -ENOMEM;
                        goto errout;
                }
@@ -165,7 +165,7 @@ static int airprime_open(struct usb_serial_port *port, struct file *filp)
                if (!urb) {
                        kfree(buffer);
                        dev_err(&port->dev, "%s - no more urbs?\n",
-                               __FUNCTION__);
+                               __func__);
                        result = -ENOMEM;
                        goto errout;
                }
@@ -180,7 +180,7 @@ static int airprime_open(struct usb_serial_port *port, struct file *filp)
                        kfree(buffer);
                        dev_err(&port->dev,
                                "%s - failed submitting read urb %d for port %d, error %d\n",
-                               __FUNCTION__, i, port->number, result);
+                               __func__, i, port->number, result);
                        goto errout;
                }
                /* remember this urb so we can kill it when the port is closed */
@@ -212,7 +212,7 @@ static void airprime_close(struct usb_serial_port *port, struct file * filp)
        struct airprime_private *priv = usb_get_serial_port_data(port);
        int i;
 
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
 
        priv->rts_state = 0;
        priv->dtr_state = 0;
@@ -242,12 +242,12 @@ static int airprime_write(struct usb_serial_port *port,
        unsigned char *buffer;
        unsigned long flags;
        int status;
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
 
        spin_lock_irqsave(&priv->lock, flags);
        if (priv->outstanding_urbs > NUM_WRITE_URBS) {
                spin_unlock_irqrestore(&priv->lock, flags);
-               dbg("%s - write limit hit\n", __FUNCTION__);
+               dbg("%s - write limit hit\n", __func__);
                return 0;
        }
        spin_unlock_irqrestore(&priv->lock, flags);
@@ -264,7 +264,7 @@ static int airprime_write(struct usb_serial_port *port,
        }
        memcpy (buffer, buf, count);
 
-       usb_serial_debug_data(debug, &port->dev, __FUNCTION__, count, buffer);
+       usb_serial_debug_data(debug, &port->dev, __func__, count, buffer);
 
        usb_fill_bulk_urb(urb, serial->dev,
                          usb_sndbulkpipe(serial->dev,
@@ -277,7 +277,7 @@ static int airprime_write(struct usb_serial_port *port,
        if (status) {
                dev_err(&port->dev,
                        "%s - usb_submit_urb(write bulk) failed with status = %d\n",
-                       __FUNCTION__, status);
+                       __func__, status);
                count = status;
                kfree (buffer);
        } else {
@@ -328,7 +328,7 @@ static int __init airprime_init(void)
 
 static void __exit airprime_exit(void)
 {
-       dbg("%s", __FUNCTION__);
+       dbg("%s", __func__);
 
        usb_deregister(&airprime_driver);
        usb_serial_deregister(&airprime_device);
index aa7a683..9d708b2 100644 (file)
@@ -173,7 +173,7 @@ static void ark3116_set_termios(struct usb_serial_port *port,
 
        config = 0;
 
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
 
        spin_lock_irqsave(&priv->lock, flags);
        if (!priv->termios_initialized) {
@@ -323,7 +323,7 @@ static int ark3116_open(struct usb_serial_port *port, struct file *filp)
        char *buf;
        int result = 0;
 
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
 
        buf = kmalloc(1, GFP_KERNEL);
        if (!buf) {
@@ -395,7 +395,7 @@ static int ark3116_ioctl(struct usb_serial_port *port, struct file *file,
                        return -EFAULT;
                return 0;
        default:
-               dbg("%s cmd 0x%04x not supported", __FUNCTION__, cmd);
+               dbg("%s cmd 0x%04x not supported", __func__, cmd);
                break;
        }
 
index b695064..5a2877c 100644 (file)
@@ -195,7 +195,7 @@ static void belkin_sa_shutdown (struct usb_serial *serial)
        struct belkin_sa_private *priv;
        int i;
        
-       dbg ("%s", __FUNCTION__);
+       dbg ("%s", __func__);
 
        /* stop reads and writes on all ports */
        for (i=0; i < serial->num_ports; ++i) {
@@ -210,7 +210,7 @@ static int  belkin_sa_open (struct usb_serial_port *port, struct file *filp)
 {
        int retval = 0;
 
-       dbg("%s port %d", __FUNCTION__, port->number);
+       dbg("%s port %d", __func__, port->number);
 
        /*Start reading from the device*/
        /* TODO: Look at possibility of submitting multiple URBs to device to
@@ -237,7 +237,7 @@ exit:
 
 static void belkin_sa_close (struct usb_serial_port *port, struct file *filp)
 {
-       dbg("%s port %d", __FUNCTION__, port->number);
+       dbg("%s port %d", __func__, port->number);
 
        /* shutdown our bulk reads and writes */
        usb_kill_urb(port->write_urb);
@@ -264,15 +264,15 @@ static void belkin_sa_read_int_callback (struct urb *urb)
        case -ESHUTDOWN:
                /* this urb is terminated, clean up */
                dbg("%s - urb shutting down with status: %d",
-                   __FUNCTION__, status);
+                   __func__, status);
                return;
        default:
                dbg("%s - nonzero urb status received: %d",
-                   __FUNCTION__, status);
+                   __func__, status);
                goto exit;
        }
 
-       usb_serial_debug_data(debug, &port->dev, __FUNCTION__, urb->actual_length, data);
+       usb_serial_debug_data(debug, &port->dev, __func__, urb->actual_length, data);
 
        /* Handle known interrupt data */
        /* ignore data[0] and data[1] */
@@ -331,7 +331,7 @@ exit:
        retval = usb_submit_urb (urb, GFP_ATOMIC);
        if (retval)
                err ("%s - usb_submit_urb failed with result %d",
-                    __FUNCTION__, retval);
+                    __func__, retval);
 }
 
 static void belkin_sa_set_termios (struct usb_serial_port *port, struct ktermios *old_termios)
@@ -478,7 +478,7 @@ static int belkin_sa_tiocmget (struct usb_serial_port *port, struct file *file)
        unsigned long control_state;
        unsigned long flags;
        
-       dbg("%s", __FUNCTION__);
+       dbg("%s", __func__);
 
        spin_lock_irqsave(&priv->lock, flags);
        control_state = priv->control_state;
@@ -499,7 +499,7 @@ static int belkin_sa_tiocmset (struct usb_serial_port *port, struct file *file,
        int rts = 0;
        int dtr = 0;
        
-       dbg("%s", __FUNCTION__);
+       dbg("%s", __func__);
 
        spin_lock_irqsave(&priv->lock, flags);
        control_state = priv->control_state;
index 66ce30c..201184c 100644 (file)
@@ -67,7 +67,7 @@ static int usb_console_setup(struct console *co, char *options)
        struct tty_struct *tty = NULL;
        struct ktermios *termios = NULL, dummy;
 
-       dbg ("%s", __FUNCTION__);
+       dbg ("%s", __func__);
 
        if (options) {
                baud = simple_strtoul(options, NULL, 10);
@@ -225,10 +225,10 @@ static void usb_console_write(struct console *co, const char *buf, unsigned coun
        if (count == 0)
                return;
 
-       dbg("%s - port %d, %d byte(s)", __FUNCTION__, port->number, count);
+       dbg("%s - port %d, %d byte(s)", __func__, port->number, count);
 
        if (!port->open_count) {
-               dbg ("%s - port not opened", __FUNCTION__);
+               dbg ("%s - port not opened", __func__);
                return;
        }
 
@@ -248,7 +248,7 @@ static void usb_console_write(struct console *co, const char *buf, unsigned coun
                        retval = serial->type->write(port, buf, i);
                else
                        retval = usb_serial_generic_write(port, buf, i);
-               dbg("%s - return value : %d", __FUNCTION__, retval);
+               dbg("%s - return value : %d", __func__, retval);
                if (lf) {
                        /* append CR after LF */
                        unsigned char cr = 13;
@@ -256,7 +256,7 @@ static void usb_console_write(struct console *co, const char *buf, unsigned coun
                                retval = serial->type->write(port, &cr, 1);
                        else
                                retval = usb_serial_generic_write(port, &cr, 1);
-                       dbg("%s - return value : %d", __FUNCTION__, retval);
+                       dbg("%s - return value : %d", __func__, retval);
                }
                buf += i;
                count -= i;
index 2af8d21..dc0ea08 100644 (file)
@@ -193,7 +193,7 @@ static int cp2101_get_config(struct usb_serial_port* port, u8 request,
 
        buf = kcalloc(length, sizeof(__le32), GFP_KERNEL);
        if (!buf) {
-               dev_err(&port->dev, "%s - out of memory.\n", __FUNCTION__);
+               dev_err(&port->dev, "%s - out of memory.\n", __func__);
                return -ENOMEM;
        }
 
@@ -214,7 +214,7 @@ static int cp2101_get_config(struct usb_serial_port* port, u8 request,
        if (result != size) {
                dev_err(&port->dev, "%s - Unable to send config request, "
                                "request=0x%x size=%d result=%d\n",
-                               __FUNCTION__, request, size, result);
+                               __func__, request, size, result);
                return -EPROTO;
        }
 
@@ -240,7 +240,7 @@ static int cp2101_set_config(struct usb_serial_port* port, u8 request,
        buf = kmalloc(length * sizeof(__le32), GFP_KERNEL);
        if (!buf) {
                dev_err(&port->dev, "%s - out of memory.\n",
-                               __FUNCTION__);
+                               __func__);
                return -ENOMEM;
        }
 
@@ -265,7 +265,7 @@ static int cp2101_set_config(struct usb_serial_port* port, u8 request,
        if ((size > 2 && result != size) || result < 0) {
                dev_err(&port->dev, "%s - Unable to send request, "
                                "request=0x%x size=%d result=%d\n",
-                               __FUNCTION__, request, size, result);
+                               __func__, request, size, result);
                return -EPROTO;
        }
 
@@ -293,11 +293,11 @@ static int cp2101_open (struct usb_serial_port *port, struct file *filp)
        struct usb_serial *serial = port->serial;
        int result;
 
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
 
        if (cp2101_set_config_single(port, CP2101_UART, UART_ENABLE)) {
                dev_err(&port->dev, "%s - Unable to enable UART\n",
-                               __FUNCTION__);
+                               __func__);
                return -EPROTO;
        }
 
@@ -312,7 +312,7 @@ static int cp2101_open (struct usb_serial_port *port, struct file *filp)
        result = usb_submit_urb(port->read_urb, GFP_KERNEL);
        if (result) {
                dev_err(&port->dev, "%s - failed resubmitting read urb, "
-                               "error %d\n", __FUNCTION__, result);
+                               "error %d\n", __func__, result);
                return result;
        }
 
@@ -329,7 +329,7 @@ static void cp2101_cleanup (struct usb_serial_port *port)
 {
        struct usb_serial *serial = port->serial;
 
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
 
        if (serial->dev) {
                /* shutdown any bulk reads that might be going on */
@@ -342,10 +342,10 @@ static void cp2101_cleanup (struct usb_serial_port *port)
 
 static void cp2101_close (struct usb_serial_port *port, struct file * filp)
 {
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
 
        /* shutdown our urbs */
-       dbg("%s - shutting down urbs", __FUNCTION__);
+       dbg("%s - shutting down urbs", __func__);
        usb_kill_urb(port->write_urb);
        usb_kill_urb(port->read_urb);
 
@@ -367,10 +367,10 @@ static void cp2101_get_termios (struct usb_serial_port *port)
        int baud;
        int bits;
 
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
 
        if (!port->tty || !port->tty->termios) {
-               dbg("%s - no tty structures", __FUNCTION__);
+               dbg("%s - no tty structures", __func__);
                return;
        }
 
@@ -379,7 +379,7 @@ static void cp2101_get_termios (struct usb_serial_port *port)
        if (baud)
                baud = BAUD_RATE_GEN_FREQ / baud;
 
-       dbg("%s - baud rate = %d", __FUNCTION__, baud);
+       dbg("%s - baud rate = %d", __func__, baud);
 
        tty_encode_baud_rate(port->tty, baud, baud);
        cflag = port->tty->termios->c_cflag;
@@ -388,24 +388,24 @@ static void cp2101_get_termios (struct usb_serial_port *port)
        cflag &= ~CSIZE;
        switch(bits & BITS_DATA_MASK) {
                case BITS_DATA_5:
-                       dbg("%s - data bits = 5", __FUNCTION__);
+                       dbg("%s - data bits = 5", __func__);
                        cflag |= CS5;
                        break;
                case BITS_DATA_6:
-                       dbg("%s - data bits = 6", __FUNCTION__);
+                       dbg("%s - data bits = 6", __func__);
                        cflag |= CS6;
                        break;
                case BITS_DATA_7:
-                       dbg("%s - data bits = 7", __FUNCTION__);
+                       dbg("%s - data bits = 7", __func__);
                        cflag |= CS7;
                        break;
                case BITS_DATA_8:
-                       dbg("%s - data bits = 8", __FUNCTION__);
+                       dbg("%s - data bits = 8", __func__);
                        cflag |= CS8;
                        break;
                case BITS_DATA_9:
                        dbg("%s - data bits = 9 (not supported, "
-                                       "using 8 data bits)", __FUNCTION__);
+                                       "using 8 data bits)", __func__);
                        cflag |= CS8;
                        bits &= ~BITS_DATA_MASK;
                        bits |= BITS_DATA_8;
@@ -413,7 +413,7 @@ static void cp2101_get_termios (struct usb_serial_port *port)
                        break;
                default:
                        dbg("%s - Unknown number of data bits, "
-                                       "using 8", __FUNCTION__);
+                                       "using 8", __func__);
                        cflag |= CS8;
                        bits &= ~BITS_DATA_MASK;
                        bits |= BITS_DATA_8;
@@ -423,35 +423,35 @@ static void cp2101_get_termios (struct usb_serial_port *port)
 
        switch(bits & BITS_PARITY_MASK) {
                case BITS_PARITY_NONE:
-                       dbg("%s - parity = NONE", __FUNCTION__);
+                       dbg("%s - parity = NONE", __func__);
                        cflag &= ~PARENB;
                        break;
                case BITS_PARITY_ODD:
-                       dbg("%s - parity = ODD", __FUNCTION__);
+                       dbg("%s - parity = ODD", __func__);
                        cflag |= (PARENB|PARODD);
                        break;
                case BITS_PARITY_EVEN:
-                       dbg("%s - parity = EVEN", __FUNCTION__);
+                       dbg("%s - parity = EVEN", __func__);
                        cflag &= ~PARODD;
                        cflag |= PARENB;
                        break;
                case BITS_PARITY_MARK:
                        dbg("%s - parity = MARK (not supported, "
-                                       "disabling parity)", __FUNCTION__);
+                                       "disabling parity)", __func__);
                        cflag &= ~PARENB;
                        bits &= ~BITS_PARITY_MASK;
                        cp2101_set_config(port, CP2101_BITS, &bits, 2);
                        break;
                case BITS_PARITY_SPACE:
                        dbg("%s - parity = SPACE (not supported, "
-                                       "disabling parity)", __FUNCTION__);
+                                       "disabling parity)", __func__);
                        cflag &= ~PARENB;
                        bits &= ~BITS_PARITY_MASK;
                        cp2101_set_config(port, CP2101_BITS, &bits, 2);
                        break;
                default:
                        dbg("%s - Unknown parity mode, "
-                                       "disabling parity", __FUNCTION__);
+                                       "disabling parity", __func__);
                        cflag &= ~PARENB;
                        bits &= ~BITS_PARITY_MASK;
                        cp2101_set_config(port, CP2101_BITS, &bits, 2);
@@ -461,21 +461,21 @@ static void cp2101_get_termios (struct usb_serial_port *port)
        cflag &= ~CSTOPB;
        switch(bits & BITS_STOP_MASK) {
                case BITS_STOP_1:
-                       dbg("%s - stop bits = 1", __FUNCTION__);
+                       dbg("%s - stop bits = 1", __func__);
                        break;
                case BITS_STOP_1_5:
                        dbg("%s - stop bits = 1.5 (not supported, "
-                                       "using 1 stop bit)", __FUNCTION__);
+                                       "using 1 stop bit)", __func__);
                        bits &= ~BITS_STOP_MASK;
                        cp2101_set_config(port, CP2101_BITS, &bits, 2);
                        break;
                case BITS_STOP_2:
-                       dbg("%s - stop bits = 2", __FUNCTION__);
+                       dbg("%s - stop bits = 2", __func__);
                        cflag |= CSTOPB;
                        break;
                default:
                        dbg("%s - Unknown number of stop bits, "
-                                       "using 1 stop bit", __FUNCTION__);
+                                       "using 1 stop bit", __func__);
                        bits &= ~BITS_STOP_MASK;
                        cp2101_set_config(port, CP2101_BITS, &bits, 2);
                        break;
@@ -483,10 +483,10 @@ static void cp2101_get_termios (struct usb_serial_port *port)
 
        cp2101_get_config(port, CP2101_MODEMCTL, modem_ctl, 16);
        if (modem_ctl[0] & 0x0008) {
-               dbg("%s - flow control = CRTSCTS", __FUNCTION__);
+               dbg("%s - flow control = CRTSCTS", __func__);
                cflag |= CRTSCTS;
        } else {
-               dbg("%s - flow control = NONE", __FUNCTION__);
+               dbg("%s - flow control = NONE", __func__);
                cflag &= ~CRTSCTS;
        }
 
@@ -500,10 +500,10 @@ static void cp2101_set_termios (struct usb_serial_port *port,
        int baud=0, bits;
        unsigned int modem_ctl[4];
 
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
 
        if (!port->tty || !port->tty->termios) {
-               dbg("%s - no tty structures", __FUNCTION__);
+               dbg("%s - no tty structures", __func__);
                return;
        }
        port->tty->termios->c_cflag &= ~CMSPAR;
@@ -542,7 +542,7 @@ static void cp2101_set_termios (struct usb_serial_port *port,
                }
 
                if (baud) {
-                       dbg("%s - Setting baud rate to %d baud", __FUNCTION__,
+                       dbg("%s - Setting baud rate to %d baud", __func__,
                                        baud);
                        if (cp2101_set_config_single(port, CP2101_BAUDRATE,
                                                (BAUD_RATE_GEN_FREQ / baud))) {
@@ -562,23 +562,23 @@ static void cp2101_set_termios (struct usb_serial_port *port,
                switch (cflag & CSIZE) {
                        case CS5:
                                bits |= BITS_DATA_5;
-                               dbg("%s - data bits = 5", __FUNCTION__);
+                               dbg("%s - data bits = 5", __func__);
                                break;
                        case CS6:
                                bits |= BITS_DATA_6;
-                               dbg("%s - data bits = 6", __FUNCTION__);
+                               dbg("%s - data bits = 6", __func__);
                                break;
                        case CS7:
                                bits |= BITS_DATA_7;
-                               dbg("%s - data bits = 7", __FUNCTION__);
+                               dbg("%s - data bits = 7", __func__);
                                break;
                        case CS8:
                                bits |= BITS_DATA_8;
-                               dbg("%s - data bits = 8", __FUNCTION__);
+                               dbg("%s - data bits = 8", __func__);
                                break;
                        /*case CS9:
                                bits |= BITS_DATA_9;
-                               dbg("%s - data bits = 9", __FUNCTION__);
+                               dbg("%s - data bits = 9", __func__);
                                break;*/
                        default:
                                dev_err(&port->dev, "cp2101 driver does not "
@@ -598,10 +598,10 @@ static void cp2101_set_termios (struct usb_serial_port *port,
                if (cflag & PARENB) {
                        if (cflag & PARODD) {
                                bits |= BITS_PARITY_ODD;
-                               dbg("%s - parity = ODD", __FUNCTION__);
+                               dbg("%s - parity = ODD", __func__);
                        } else {
                                bits |= BITS_PARITY_EVEN;
-                               dbg("%s - parity = EVEN", __FUNCTION__);
+                               dbg("%s - parity = EVEN", __func__);
                        }
                }
                if (cp2101_set_config(port, CP2101_BITS, &bits, 2))
@@ -614,10 +614,10 @@ static void cp2101_set_termios (struct usb_serial_port *port,
                bits &= ~BITS_STOP_MASK;
                if (cflag & CSTOPB) {
                        bits |= BITS_STOP_2;
-                       dbg("%s - stop bits = 2", __FUNCTION__);
+                       dbg("%s - stop bits = 2", __func__);
                } else {
                        bits |= BITS_STOP_1;
-                       dbg("%s - stop bits = 1", __FUNCTION__);
+                       dbg("%s - stop bits = 1", __func__);
                }
                if (cp2101_set_config(port, CP2101_BITS, &bits, 2))
                        dev_err(&port->dev, "Number of stop bits requested "
@@ -627,23 +627,23 @@ static void cp2101_set_termios (struct usb_serial_port *port,
        if ((cflag & CRTSCTS) != (old_cflag & CRTSCTS)) {
                cp2101_get_config(port, CP2101_MODEMCTL, modem_ctl, 16);
                dbg("%s - read modem controls = 0x%.4x 0x%.4x 0x%.4x 0x%.4x",
-                               __FUNCTION__, modem_ctl[0], modem_ctl[1],
+                               __func__, modem_ctl[0], modem_ctl[1],
                                modem_ctl[2], modem_ctl[3]);
 
                if (cflag & CRTSCTS) {
                        modem_ctl[0] &= ~0x7B;
                        modem_ctl[0] |= 0x09;
                        modem_ctl[1] = 0x80;
-                       dbg("%s - flow control = CRTSCTS", __FUNCTION__);
+                       dbg("%s - flow control = CRTSCTS", __func__);
                } else {
                        modem_ctl[0] &= ~0x7B;
                        modem_ctl[0] |= 0x01;
                        modem_ctl[1] |= 0x40;
-                       dbg("%s - flow control = NONE", __FUNCTION__);
+                       dbg("%s - flow control = NONE", __func__);
                }
 
                dbg("%s - write modem controls = 0x%.4x 0x%.4x 0x%.4x 0x%.4x",
-                               __FUNCTION__, modem_ctl[0], modem_ctl[1],
+                               __func__, modem_ctl[0], modem_ctl[1],
                                modem_ctl[2], modem_ctl[3]);
                cp2101_set_config(port, CP2101_MODEMCTL, modem_ctl, 16);
        }
@@ -655,7 +655,7 @@ static int cp2101_tiocmset (struct usb_serial_port *port, struct file *file,
 {
        int control = 0;
 
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
 
        if (set & TIOCM_RTS) {
                control |= CONTROL_RTS;
@@ -674,7 +674,7 @@ static int cp2101_tiocmset (struct usb_serial_port *port, struct file *file,
                control |= CONTROL_WRITE_DTR;
        }
 
-       dbg("%s - control = 0x%.4x", __FUNCTION__, control);
+       dbg("%s - control = 0x%.4x", __func__, control);
 
        return cp2101_set_config(port, CP2101_CONTROL, &control, 2);
 
@@ -684,7 +684,7 @@ static int cp2101_tiocmget (struct usb_serial_port *port, struct file *file)
 {
        int control, result;
 
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
 
        cp2101_get_config(port, CP2101_CONTROL, &control, 1);
 
@@ -695,7 +695,7 @@ static int cp2101_tiocmget (struct usb_serial_port *port, struct file *file)
                |((control & CONTROL_RING)? TIOCM_RI  : 0)
                |((control & CONTROL_DCD) ? TIOCM_CD  : 0);
 
-       dbg("%s - control = 0x%.2x", __FUNCTION__, control);
+       dbg("%s - control = 0x%.2x", __func__, control);
 
        return result;
 }
@@ -704,12 +704,12 @@ static void cp2101_break_ctl (struct usb_serial_port *port, int break_state)
 {
        int state;
 
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
        if (break_state == 0)
                state = BREAK_OFF;
        else
                state = BREAK_ON;
-       dbg("%s - turning break %s", __FUNCTION__,
+       dbg("%s - turning break %s", __func__,
                        state==BREAK_OFF ? "off" : "on");
        cp2101_set_config(port, CP2101_BREAK, &state, 2);
 }
@@ -725,7 +725,7 @@ static void cp2101_shutdown (struct usb_serial *serial)
 {
        int i;
 
-       dbg("%s", __FUNCTION__);
+       dbg("%s", __func__);
 
        /* Stop reads and writes on all ports */
        for (i=0; i < serial->num_ports; ++i) {
index cbae876..5348e97 100644 (file)
@@ -116,7 +116,7 @@ static int cyberjack_startup (struct usb_serial *serial)
        struct cyberjack_private *priv;
        int i;
 
-       dbg("%s", __FUNCTION__);
+       dbg("%s", __func__);
 
        /* allocate the private data structure */
        priv = kmalloc(sizeof(struct cyberjack_private), GFP_KERNEL);
@@ -139,7 +139,7 @@ static int cyberjack_startup (struct usb_serial *serial)
                                        GFP_KERNEL);
                if (result)
                        err(" usb_submit_urb(read int) failed");
-               dbg("%s - usb_submit_urb(int urb)", __FUNCTION__);
+               dbg("%s - usb_submit_urb(int urb)", __func__);
        }
 
        return( 0 );
@@ -149,7 +149,7 @@ static void cyberjack_shutdown (struct usb_serial *serial)
 {
        int i;
        
-       dbg("%s", __FUNCTION__);
+       dbg("%s", __func__);
 
        for (i=0; i < serial->num_ports; ++i) {
                usb_kill_urb(serial->port[i]->interrupt_in_urb);
@@ -165,9 +165,9 @@ static int  cyberjack_open (struct usb_serial_port *port, struct file *filp)
        unsigned long flags;
        int result = 0;
 
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
 
-       dbg("%s - usb_clear_halt", __FUNCTION__ );
+       dbg("%s - usb_clear_halt", __func__ );
        usb_clear_halt(port->serial->dev, port->write_urb->pipe);
 
        /* force low_latency on so that our tty_push actually forces
@@ -188,7 +188,7 @@ static int  cyberjack_open (struct usb_serial_port *port, struct file *filp)
 
 static void cyberjack_close (struct usb_serial_port *port, struct file *filp)
 {
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
 
        if (port->serial->dev) {
                /* shutdown any bulk reads that might be going on */
@@ -205,17 +205,17 @@ static int cyberjack_write (struct usb_serial_port *port, const unsigned char *b
        int result;
        int wrexpected;
 
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
 
        if (count == 0) {
-               dbg("%s - write request of 0 bytes", __FUNCTION__);
+               dbg("%s - write request of 0 bytes", __func__);
                return (0);
        }
 
        spin_lock_bh(&port->lock);
        if (port->write_urb_busy) {
                spin_unlock_bh(&port->lock);
-               dbg("%s - already writing", __FUNCTION__);
+               dbg("%s - already writing", __func__);
                return 0;
        }
        port->write_urb_busy = 1;
@@ -234,13 +234,13 @@ static int cyberjack_write (struct usb_serial_port *port, const unsigned char *b
        /* Copy data */
        memcpy (priv->wrbuf+priv->wrfilled, buf, count);
 
-       usb_serial_debug_data(debug, &port->dev, __FUNCTION__, count,
+       usb_serial_debug_data(debug, &port->dev, __func__, count,
                priv->wrbuf+priv->wrfilled);
        priv->wrfilled += count;
 
        if( priv->wrfilled >= 3 ) {
                wrexpected = ((int)priv->wrbuf[2]<<8)+priv->wrbuf[1]+3;
-               dbg("%s - expected data: %d", __FUNCTION__, wrexpected);
+               dbg("%s - expected data: %d", __func__, wrexpected);
        } else {
                wrexpected = sizeof(priv->wrbuf);
        }
@@ -249,7 +249,7 @@ static int cyberjack_write (struct usb_serial_port *port, const unsigned char *b
                /* We have enough data to begin transmission */
                int length;
 
-               dbg("%s - transmitting data (frame 1)", __FUNCTION__);
+               dbg("%s - transmitting data (frame 1)", __func__);
                length = (wrexpected > port->bulk_out_size) ? port->bulk_out_size : wrexpected;
 
                memcpy (port->write_urb->transfer_buffer, priv->wrbuf, length );
@@ -267,7 +267,7 @@ static int cyberjack_write (struct usb_serial_port *port, const unsigned char *b
                /* send the data out the bulk port */
                result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
                if (result) {
-                       err("%s - failed submitting write urb, error %d", __FUNCTION__, result);
+                       err("%s - failed submitting write urb, error %d", __func__, result);
                        /* Throw away data. No better idea what to do with it. */
                        priv->wrfilled=0;
                        priv->wrsent=0;
@@ -276,11 +276,11 @@ static int cyberjack_write (struct usb_serial_port *port, const unsigned char *b
                        return 0;
                }
 
-               dbg("%s - priv->wrsent=%d", __FUNCTION__,priv->wrsent);
-               dbg("%s - priv->wrfilled=%d", __FUNCTION__,priv->wrfilled);
+               dbg("%s - priv->wrsent=%d", __func__,priv->wrsent);
+               dbg("%s - priv->wrfilled=%d", __func__,priv->wrfilled);
 
                if( priv->wrsent>=priv->wrfilled ) {
-                       dbg("%s - buffer cleaned", __FUNCTION__);
+                       dbg("%s - buffer cleaned", __func__);
                        memset( priv->wrbuf, 0, sizeof(priv->wrbuf) );
                        priv->wrfilled=0;
                        priv->wrsent=0;
@@ -305,13 +305,13 @@ static void cyberjack_read_int_callback( struct urb *urb )
        int status = urb->status;
        int result;
 
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
 
        /* the urb might have been killed. */
        if (status)
                return;
 
-       usb_serial_debug_data(debug, &port->dev, __FUNCTION__, urb->actual_length, data);
+       usb_serial_debug_data(debug, &port->dev, __func__, urb->actual_length, data);
 
        /* React only to interrupts signaling a bulk_in transfer */
        if( (urb->actual_length==4) && (data[0]==0x01) ) {
@@ -333,7 +333,7 @@ static void cyberjack_read_int_callback( struct urb *urb )
                /* "+=" is probably more fault tollerant than "=" */
                priv->rdtodo += size;
 
-               dbg("%s - rdtodo: %d", __FUNCTION__, priv->rdtodo);
+               dbg("%s - rdtodo: %d", __func__, priv->rdtodo);
 
                spin_unlock(&priv->lock);
 
@@ -341,8 +341,8 @@ static void cyberjack_read_int_callback( struct urb *urb )
                        port->read_urb->dev = port->serial->dev;
                        result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
                        if( result )
-                               err("%s - failed resubmitting read urb, error %d", __FUNCTION__, result);
-                       dbg("%s - usb_submit_urb(read urb)", __FUNCTION__);
+                               err("%s - failed resubmitting read urb, error %d", __func__, result);
+                       dbg("%s - usb_submit_urb(read urb)", __func__);
                }
        }
 
@@ -351,7 +351,7 @@ resubmit:
        result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
        if (result)
                err(" usb_submit_urb(read int) failed");
-       dbg("%s - usb_submit_urb(int urb)", __FUNCTION__);
+       dbg("%s - usb_submit_urb(int urb)", __func__);
 }
 
 static void cyberjack_read_bulk_callback (struct urb *urb)
@@ -364,18 +364,18 @@ static void cyberjack_read_bulk_callback (struct urb *urb)
        int result;
        int status = urb->status;
 
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
 
-       usb_serial_debug_data(debug, &port->dev, __FUNCTION__, urb->actual_length, data);
+       usb_serial_debug_data(debug, &port->dev, __func__, urb->actual_length, data);
        if (status) {
                dbg("%s - nonzero read bulk status received: %d",
-                   __FUNCTION__, status);
+                   __func__, status);
                return;
        }
 
        tty = port->tty;
        if (!tty) {
-               dbg("%s - ignoring since device not open\n", __FUNCTION__);
+               dbg("%s - ignoring since device not open\n", __func__);
                return;
        }
        if (urb->actual_length) {
@@ -394,15 +394,15 @@ static void cyberjack_read_bulk_callback (struct urb *urb)
 
        spin_unlock(&priv->lock);
 
-       dbg("%s - rdtodo: %d", __FUNCTION__, todo);
+       dbg("%s - rdtodo: %d", __func__, todo);
 
        /* Continue to read if we have still urbs to do. */
        if( todo /* || (urb->actual_length==port->bulk_in_endpointAddress)*/ ) {
                port->read_urb->dev = port->serial->dev;
                result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
                if (result)
-                       err("%s - failed resubmitting read urb, error %d", __FUNCTION__, result);
-               dbg("%s - usb_submit_urb(read urb)", __FUNCTION__);
+                       err("%s - failed resubmitting read urb, error %d", __func__, result);
+               dbg("%s - usb_submit_urb(read urb)", __func__);
        }
 }
 
@@ -412,12 +412,12 @@ static void cyberjack_write_bulk_callback (struct urb *urb)
        struct cyberjack_private *priv = usb_get_serial_port_data(port);
        int status = urb->status;
 
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
 
        port->write_urb_busy = 0;
        if (status) {
                dbg("%s - nonzero write bulk status received: %d",
-                   __FUNCTION__, status);
+                   __func__, status);
                return;
        }
 
@@ -427,7 +427,7 @@ static void cyberjack_write_bulk_callback (struct urb *urb)
        if( priv->wrfilled ) {
                int length, blksize, result;
 
-               dbg("%s - transmitting data (frame n)", __FUNCTION__);
+               dbg("%s - transmitting data (frame n)", __func__);
 
                length = ((priv->wrfilled - priv->wrsent) > port->bulk_out_size) ?
                        port->bulk_out_size : (priv->wrfilled - priv->wrsent);
@@ -448,20 +448,20 @@ static void cyberjack_write_bulk_callback (struct urb *urb)
                /* send the data out the bulk port */
                result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
                if (result) {
-                       err("%s - failed submitting write urb, error %d", __FUNCTION__, result);
+                       err("%s - failed submitting write urb, error %d", __func__, result);
                        /* Throw away data. No better idea what to do with it. */
                        priv->wrfilled=0;
                        priv->wrsent=0;
                        goto exit;
                }
 
-               dbg("%s - priv->wrsent=%d", __FUNCTION__,priv->wrsent);
-               dbg("%s - priv->wrfilled=%d", __FUNCTION__,priv->wrfilled);
+               dbg("%s - priv->wrsent=%d", __func__,priv->wrsent);
+               dbg("%s - priv->wrfilled=%d", __func__,priv->wrfilled);
 
                blksize = ((int)priv->wrbuf[2]<<8)+priv->wrbuf[1]+3;
 
                if( (priv->wrsent>=priv->wrfilled) || (priv->wrsent>=blksize) ) {
-                       dbg("%s - buffer cleaned", __FUNCTION__);
+                       dbg("%s - buffer cleaned", __func__);
                        memset( priv->wrbuf, 0, sizeof(priv->wrbuf) );
                        priv->wrfilled=0;
                        priv->wrsent=0;
index d8304ea..01dfc0a 100644 (file)
@@ -330,7 +330,7 @@ static int cypress_serial_control (struct usb_serial_port *port, speed_t baud_ra
        __u8 feature_buffer[5];
        unsigned long flags;
 
-       dbg("%s", __FUNCTION__);
+       dbg("%s", __func__);
        
        priv = usb_get_serial_port_data(port);
 
@@ -345,7 +345,7 @@ static int cypress_serial_control (struct usb_serial_port *port, speed_t baud_ra
                                new_baudrate = priv->baud_rate;
                        /* Change of speed ? */
                        else if (baud_rate != priv->baud_rate) {
-                               dbg("%s - baud rate is changing", __FUNCTION__);
+                               dbg("%s - baud rate is changing", __func__);
                                retval = analyze_baud_rate(port, baud_rate);
                                if (retval >=  0) {
                                        new_baudrate = retval;
@@ -353,7 +353,7 @@ static int cypress_serial_control (struct usb_serial_port *port, speed_t baud_ra
                                            __func__, new_baudrate);
                                }
                        }
-                       dbg("%s - baud rate is being sent as %d", __FUNCTION__, new_baudrate);
+                       dbg("%s - baud rate is being sent as %d", __func__, new_baudrate);
                        
                        memset(feature_buffer, 0, sizeof(feature_buffer));
                        /* fill the feature_buffer with new configuration */
@@ -367,8 +367,8 @@ static int cypress_serial_control (struct usb_serial_port *port, speed_t baud_ra
                        /* 1 bit gap */
                        feature_buffer[4] |= (reset << 7);   /* assign reset at end of byte, 1 bit space */
                                
-                       dbg("%s - device is being sent this feature report:", __FUNCTION__);
-                       dbg("%s - %02X - %02X - %02X - %02X - %02X", __FUNCTION__, feature_buffer[0], feature_buffer[1],
+                       dbg("%s - device is being sent this feature report:", __func__);
+                       dbg("%s - %02X - %02X - %02X - %02X - %02X", __func__, feature_buffer[0], feature_buffer[1],
                            feature_buffer[2], feature_buffer[3], feature_buffer[4]);
                        
                        do {
@@ -386,7 +386,7 @@ static int cypress_serial_control (struct usb_serial_port *port, speed_t baud_ra
                                 retval != -ENODEV);
 
                        if (retval != sizeof(feature_buffer)) {
-                               err("%s - failed sending serial line settings - %d", __FUNCTION__, retval);
+                               err("%s - failed sending serial line settings - %d", __func__, retval);
                                cypress_set_dead(port);
                        } else {
                                spin_lock_irqsave(&priv->lock, flags);
@@ -406,7 +406,7 @@ static int cypress_serial_control (struct usb_serial_port *port, speed_t baud_ra
                                   to crash the hardware. */
                                return -ENOTTY;
                        }
-                       dbg("%s - retreiving serial line settings", __FUNCTION__);
+                       dbg("%s - retreiving serial line settings", __func__);
                        /* set initial values in feature buffer */
                        memset(feature_buffer, 0, sizeof(feature_buffer));
 
@@ -425,7 +425,7 @@ static int cypress_serial_control (struct usb_serial_port *port, speed_t baud_ra
                                 retval != -ENODEV);
 
                        if (retval != sizeof(feature_buffer)) {
-                               err("%s - failed to retrieve serial line settings - %d", __FUNCTION__, retval);
+                               err("%s - failed to retrieve serial line settings - %d", __func__, retval);
                                cypress_set_dead(port);
                                return retval;
                        } else {
@@ -473,7 +473,7 @@ static int generic_startup (struct usb_serial *serial)
        struct cypress_private *priv;
        struct usb_serial_port *port = serial->port[0];
 
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
 
        priv = kzalloc(sizeof (struct cypress_private), GFP_KERNEL);
        if (!priv)
@@ -509,12 +509,12 @@ static int generic_startup (struct usb_serial *serial)
                priv->write_urb_interval = interval;
                priv->read_urb_interval = interval;
                dbg("%s - port %d read & write intervals forced to %d",
-                   __FUNCTION__,port->number,interval);
+                   __func__,port->number,interval);
        } else {
                priv->write_urb_interval = port->interrupt_out_urb->interval;
                priv->read_urb_interval = port->interrupt_in_urb->interval;
                dbg("%s - port %d intervals: read=%d write=%d",
-                   __FUNCTION__,port->number,
+                   __func__,port->number,
                    priv->read_urb_interval,priv->write_urb_interval);
        }
        usb_set_serial_port_data(port, priv);
@@ -528,10 +528,10 @@ static int cypress_earthmate_startup (struct usb_serial *serial)
        struct cypress_private *priv;
        struct usb_serial_port *port = serial->port[0];
 
-       dbg("%s", __FUNCTION__);
+       dbg("%s", __func__);
 
        if (generic_startup(serial)) {
-               dbg("%s - Failed setting up port %d", __FUNCTION__,
+               dbg("%s - Failed setting up port %d", __func__,
                                port->number);
                return 1;
        }
@@ -559,10 +559,10 @@ static int cypress_hidcom_startup (struct usb_serial *serial)
 {
        struct cypress_private *priv;
 
-       dbg("%s", __FUNCTION__);
+       dbg("%s", __func__);
 
        if (generic_startup(serial)) {
-               dbg("%s - Failed setting up port %d", __FUNCTION__,
+               dbg("%s - Failed setting up port %d", __func__,
                                serial->port[0]->number);
                return 1;
        }
@@ -578,10 +578,10 @@ static int cypress_ca42v2_startup (struct usb_serial *serial)
 {
        struct cypress_private *priv;
 
-       dbg("%s", __FUNCTION__);
+       dbg("%s", __func__);
 
        if (generic_startup(serial)) {
-               dbg("%s - Failed setting up port %d", __FUNCTION__,
+               dbg("%s - Failed setting up port %d", __func__,
                                serial->port[0]->number);
                return 1;
        }
@@ -597,7 +597,7 @@ static void cypress_shutdown (struct usb_serial *serial)
 {
        struct cypress_private *priv;
 
-       dbg ("%s - port %d", __FUNCTION__, serial->port[0]->number);
+       dbg ("%s - port %d", __func__, serial->port[0]->number);
 
        /* all open ports are closed at this point */
 
@@ -618,7 +618,7 @@ static int cypress_open (struct usb_serial_port *port, struct file *filp)
        unsigned long flags;
        int result = 0;
 
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
 
        if (!priv->comm_is_ok)
                return -EIO;
@@ -646,16 +646,16 @@ static int cypress_open (struct usb_serial_port *port, struct file *filp)
        result = cypress_write(port, NULL, 0);
 
        if (result) {
-               dev_err(&port->dev, "%s - failed setting the control lines - error %d\n", __FUNCTION__, result);
+               dev_err(&port->dev, "%s - failed setting the control lines - error %d\n", __func__, result);
                return result;
        } else
-               dbg("%s - success setting the control lines", __FUNCTION__);    
+               dbg("%s - success setting the control lines", __func__);
 
        cypress_set_termios(port, &priv->tmp_termios);
 
        /* setup the port and start reading from the device */
        if(!port->interrupt_in_urb){
-               err("%s - interrupt_in_urb is empty!", __FUNCTION__);
+               err("%s - interrupt_in_urb is empty!", __func__);
                return(-1);
        }
 
@@ -666,7 +666,7 @@ static int cypress_open (struct usb_serial_port *port, struct file *filp)
        result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 
        if (result){
-               dev_err(&port->dev, "%s - failed submitting read urb, error %d\n", __FUNCTION__, result);
+               dev_err(&port->dev, "%s - failed submitting read urb, error %d\n", __func__, result);
                cypress_set_dead(port);
        }
 
@@ -682,7 +682,7 @@ static void cypress_close(struct usb_serial_port *port, struct file * filp)
        long timeout;
        wait_queue_t wait;
 
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
 
        /* wait for data to drain from buffer */
        spin_lock_irq(&priv->lock);
@@ -720,7 +720,7 @@ static void cypress_close(struct usb_serial_port *port, struct file * filp)
                timeout = 2*HZ;
        schedule_timeout_interruptible(timeout);
 
-       dbg("%s - stopping urbs", __FUNCTION__);
+       dbg("%s - stopping urbs", __func__);
        usb_kill_urb (port->interrupt_in_urb);
        usb_kill_urb (port->interrupt_out_urb);
 
@@ -749,7 +749,7 @@ static int cypress_write(struct usb_serial_port *port, const unsigned char *buf,
        struct cypress_private *priv = usb_get_serial_port_data(port);
        unsigned long flags;
        
-       dbg("%s - port %d, %d bytes", __FUNCTION__, port->number, count);
+       dbg("%s - port %d, %d bytes", __func__, port->number, count);
 
        /* line control commands, which need to be executed immediately,
           are not put into the buffer for obvious reasons.
@@ -782,12 +782,12 @@ static void cypress_send(struct usb_serial_port *port)
        if (!priv->comm_is_ok)
                return;
 
-       dbg("%s - port %d", __FUNCTION__, port->number);
-       dbg("%s - interrupt out size is %d", __FUNCTION__, port->interrupt_out_size);
+       dbg("%s - port %d", __func__, port->number);
+       dbg("%s - interrupt out size is %d", __func__, port->interrupt_out_size);
        
        spin_lock_irqsave(&priv->lock, flags);
        if (priv->write_urb_in_use) {
-               dbg("%s - can't write, urb in use", __FUNCTION__);
+               dbg("%s - can't write, urb in use", __func__);
                spin_unlock_irqrestore(&priv->lock, flags);
                return;
        }
@@ -816,7 +816,7 @@ static void cypress_send(struct usb_serial_port *port)
 
        if (priv->cmd_ctrl) {
                priv->cmd_count++;
-               dbg("%s - line control command being issued", __FUNCTION__);
+               dbg("%s - line control command being issued", __func__);
                spin_unlock_irqrestore(&priv->lock, flags);
                goto send;
        } else
@@ -838,7 +838,7 @@ static void cypress_send(struct usb_serial_port *port)
                port->interrupt_out_buffer[0] |= count;
        }
 
-       dbg("%s - count is %d", __FUNCTION__, count);
+       dbg("%s - count is %d", __func__, count);
 
 send:
        spin_lock_irqsave(&priv->lock, flags);
@@ -851,7 +851,7 @@ send:
                actual_size = count +
                              (priv->pkt_fmt == packet_format_1 ? 2 : 1);
 
-       usb_serial_debug_data(debug, &port->dev, __FUNCTION__, port->interrupt_out_size,
+       usb_serial_debug_data(debug, &port->dev, __func__, port->interrupt_out_size,
                              port->interrupt_out_urb->transfer_buffer);
 
        usb_fill_int_urb(port->interrupt_out_urb, port->serial->dev,
@@ -860,7 +860,7 @@ send:
                cypress_write_int_callback, port, priv->write_urb_interval);
        result = usb_submit_urb (port->interrupt_out_urb, GFP_ATOMIC);
        if (result) {
-               dev_err(&port->dev, "%s - failed submitting write urb, error %d\n", __FUNCTION__,
+               dev_err(&port->dev, "%s - failed submitting write urb, error %d\n", __func__,
                        result);
                priv->write_urb_in_use = 0;
                cypress_set_dead(port);
@@ -884,13 +884,13 @@ static int cypress_write_room(struct usb_serial_port *port)
        int room = 0;
        unsigned long flags;
 
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
 
        spin_lock_irqsave(&priv->lock, flags);
        room = cypress_buf_space_avail(priv->buf);
        spin_unlock_irqrestore(&priv->lock, flags);
 
-       dbg("%s - returns %d", __FUNCTION__, room);
+       dbg("%s - returns %d", __func__, room);
        return room;
 }
 
@@ -902,7 +902,7 @@ static int cypress_tiocmget (struct usb_serial_port *port, struct file *file)
        unsigned int result = 0;
        unsigned long flags;
        
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
 
        spin_lock_irqsave(&priv->lock, flags);
        control = priv->line_control;
@@ -916,7 +916,7 @@ static int cypress_tiocmget (struct usb_serial_port *port, struct file *file)
                | ((status & UART_RI)         ? TIOCM_RI  : 0)
                | ((status & UART_CD)         ? TIOCM_CD  : 0);
 
-       dbg("%s - result = %x", __FUNCTION__, result);
+       dbg("%s - result = %x", __func__, result);
 
        return result;
 }
@@ -928,7 +928,7 @@ static int cypress_tiocmset (struct usb_serial_port *port, struct file *file,
        struct cypress_private *priv = usb_get_serial_port_data(port);
        unsigned long flags;
        
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
 
        spin_lock_irqsave(&priv->lock, flags);
        if (set & TIOCM_RTS)
@@ -950,7 +950,7 @@ static int cypress_ioctl (struct usb_serial_port *port, struct file * file, unsi
 {
        struct cypress_private *priv = usb_get_serial_port_data(port);
 
-       dbg("%s - port %d, cmd 0x%.4x", __FUNCTION__, port->number, cmd);
+       dbg("%s - port %d, cmd 0x%.4x", __func__, port->number, cmd);
 
        switch (cmd) {
                /* This code comes from drivers/char/serial.c and ftdi_sio.c */
@@ -988,7 +988,7 @@ static int cypress_ioctl (struct usb_serial_port *port, struct file * file, unsi
                        break;
        }
 
-       dbg("%s - arg not supported - it was 0x%04x - check include/asm/ioctls.h", __FUNCTION__, cmd);
+       dbg("%s - arg not supported - it was 0x%04x - check include/asm/ioctls.h", __func__, cmd);
 
        return -ENOIOCTLCMD;
 } /* cypress_ioctl */
@@ -1005,7 +1005,7 @@ static void cypress_set_termios (struct usb_serial_port *port,
        __u8 oldlines;
        int linechange = 0;
 
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
 
        tty = port->tty;
 
@@ -1076,7 +1076,7 @@ static void cypress_set_termios (struct usb_serial_port *port,
                                break;
                        default:
                                err("%s - CSIZE was set, but not CS5-CS8",
-                                               __FUNCTION__);
+                                               __func__);
                                data_bits = 3;
                }
        } else
@@ -1086,14 +1086,14 @@ static void cypress_set_termios (struct usb_serial_port *port,
        oldlines = priv->line_control;
        if ((cflag & CBAUD) == B0) {
                /* drop dtr and rts */
-               dbg("%s - dropping the lines, baud rate 0bps", __FUNCTION__);
+               dbg("%s - dropping the lines, baud rate 0bps", __func__);
                priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
        } else
                priv->line_control = (CONTROL_DTR | CONTROL_RTS);
        spin_unlock_irqrestore(&priv->lock, flags);
 
        dbg("%s - sending %d stop_bits, %d parity_enable, %d parity_type, "
-                       "%d data_bits (+5)", __FUNCTION__, stop_bits,
+                       "%d data_bits (+5)", __func__, stop_bits,
                        parity_enable, parity_type, data_bits);
 
        cypress_serial_control(port, tty_get_baud_rate(tty), data_bits, stop_bits,
@@ -1154,13 +1154,13 @@ static int cypress_chars_in_buffer(struct usb_serial_port *port)
        int chars = 0;
        unsigned long flags;
 
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
        
        spin_lock_irqsave(&priv->lock, flags);
        chars = cypress_buf_data_avail(priv->buf);
        spin_unlock_irqrestore(&priv->lock, flags);
 
-       dbg("%s - returns %d", __FUNCTION__, chars);
+       dbg("%s - returns %d", __func__, chars);
        return chars;
 }
 
@@ -1170,7 +1170,7 @@ static void cypress_throttle (struct usb_serial_port *port)
        struct cypress_private *priv = usb_get_serial_port_data(port);
        unsigned long flags;
 
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
 
        spin_lock_irqsave(&priv->lock, flags);
        priv->rx_flags = THROTTLED;
@@ -1184,7 +1184,7 @@ static void cypress_unthrottle (struct usb_serial_port *port)
        int actually_throttled, result;
        unsigned long flags;
 
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
 
        spin_lock_irqsave(&priv->lock, flags);
        actually_throttled = priv->rx_flags & ACTUALLY_THROTTLED;
@@ -1200,7 +1200,7 @@ static void cypress_unthrottle (struct usb_serial_port *port)
                result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
                if (result) {
                        dev_err(&port->dev, "%s - failed submitting read urb, "
-                                       "error %d\n", __FUNCTION__, result);
+                                       "error %d\n", __func__, result);
                        cypress_set_dead(port);
                }
        }
@@ -1221,7 +1221,7 @@ static void cypress_read_int_callback(struct urb *urb)
        int i = 0;
        int status = urb->status;
 
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
 
        switch (status) {
        case 0: /* success */
@@ -1237,14 +1237,14 @@ static void cypress_read_int_callback(struct urb *urb)
        default:
                /* something ugly is going on... */
                dev_err(&urb->dev->dev,"%s - unexpected nonzero read status received: %d\n",
-                       __FUNCTION__, status);
+                       __func__, status);
                cypress_set_dead(port);
                return;
        }
 
        spin_lock_irqsave(&priv->lock, flags);
        if (priv->rx_flags & THROTTLED) {
-               dbg("%s - now throttling", __FUNCTION__);
+               dbg("%s - now throttling", __func__);
                priv->rx_flags |= ACTUALLY_THROTTLED;
                spin_unlock_irqrestore(&priv->lock, flags);
                return;
@@ -1253,7 +1253,7 @@ static void cypress_read_int_callback(struct urb *urb)
 
        tty = port->tty;
        if (!tty) {
-               dbg("%s - bad tty pointer - exiting", __FUNCTION__);
+               dbg("%s - bad tty pointer - exiting", __func__);
                return;
        }
 
@@ -1285,7 +1285,7 @@ static void cypress_read_int_callback(struct urb *urb)
                goto continue_read;
        }
 
-       usb_serial_debug_data (debug, &port->dev, __FUNCTION__,
+       usb_serial_debug_data (debug, &port->dev, __func__,
                        urb->actual_length, data);
 
        spin_lock_irqsave(&priv->lock, flags);
@@ -1302,7 +1302,7 @@ static void cypress_read_int_callback(struct urb *urb)
         * though */
        if (tty && !(tty->termios->c_cflag & CLOCAL) &&
                        !(priv->current_status & UART_CD)) {
-               dbg("%s - calling hangup", __FUNCTION__);
+               dbg("%s - calling hangup", __func__);
                tty_hangup(tty);
                goto continue_read;
        }
@@ -1315,7 +1315,7 @@ static void cypress_read_int_callback(struct urb *urb)
        if (priv->current_status & CYP_ERROR) {
                spin_unlock_irqrestore(&priv->lock, flags);
                tty_flag = TTY_PARITY;
-               dbg("%s - Parity Error detected", __FUNCTION__);
+               dbg("%s - Parity Error detected", __func__);
        } else
                spin_unlock_irqrestore(&priv->lock, flags);
 
@@ -1349,7 +1349,7 @@ continue_read:
                result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
                if (result) {
                        dev_err(&urb->dev->dev, "%s - failed resubmitting "
-                                       "read urb, error %d\n", __FUNCTION__,
+                                       "read urb, error %d\n", __func__,
                                        result);
                        cypress_set_dead(port);
                }
@@ -1366,7 +1366,7 @@ static void cypress_write_int_callback(struct urb *urb)
        int result;
        int status = urb->status;
 
-       dbg("%s - port %d", __FUNCTION__, port->number);
+       dbg("%s - port %d", __func__, port->number);
 
        switch (status) {
                case 0:
@@ -1377,7 +1377,7 @@ static void cypress_write_int_callback(struct urb *urb)
                case -ESHUTDOWN:
                        /* this urb is terminated, clean up */
                        dbg("%s - urb shutting down with status: %d",
-                           __FUNCTION__, status);
+                           __func__, status);
                        priv->write_urb_in_use = 0;
                        return;
                case -EPIPE: /* no break needed; clear halt and resubmit */
@@ -1386,19 +1386,19 @@ static void cypress_write_int_callback(struct urb *urb)
                        usb_clear_halt(port->serial->dev, 0x02);
                        /* error in the urb, so we have to resubmit it */
                        dbg("%s - nonzero write bulk status received: %d",
-                           __FUNCTION__, status);
+                           __func__, status);
                        port->interrupt_out_urb->transfer_buffer_length = 1;
                        port->interrupt_out_urb->dev = port->serial->dev;
                        result = usb_submit_urb(port->interrupt_out_urb, GFP_ATOMIC);
                        if (!result)
                                return;
                        dev_err(&urb->dev->dev, "%s - failed resubmitting write urb, error %d\n",
-                               __FUNCTION__, result);
+                               __func__, result);
                        cypress_set_dead(port);
                        break;
                default:
                        dev_err(&urb->dev->dev,"%s - unexpected nonzero write status received: %d\n",
-                               __FUNCTION__, status);
+                               __func__, status);
                        cypress_set_dead(port);
                        break;
        }
@@ -1603,7 +1603,7 @@ static int __init cypress_init(void)
 {
        int retval;
        
-       dbg("%s", __FUNCTION__);
+       dbg("%s", __func__);
        
        retval = usb_serial_register(&cypress_earthmate_device);
        if (retval)
@@ -1634,7 +1634,7 @@ failed_em_register:
 
 static void __exit cypress_exit (void)
 {
-       dbg("%s", __FUNCTION__);
+       dbg("%s", __func__);
 
        usb_deregister (&cypress_driver);
        usb_serial_deregister (&cypress_earthmate_device);
index 4e3d599..c7cbc02 100644 (file)
@@ -659,7 +659,7 @@ static int digi_write_oob_command(struct usb_serial_port *port,
        }
        spin_unlock_irqrestore(&oob_priv->dp_port_lock, flags);
        if (ret)
-               err("%s: usb_submit_urb failed, ret=%d", __FUNCTION__, ret);
+               err("%s: usb_submit_urb failed, ret=%d", __func__, ret);
        return ret;
 
 }
@@ -740,7 +740,7 @@ static int digi_write_inb_command(struct usb_serial_port *port,
 
        if (ret)
                err("%s: usb_submit_urb failed, ret=%d, port=%d",
-                       __FUNCTION__, ret, priv->dp_port_num);
+                       __func__, ret, priv->dp_port_num);
        return ret;
 }
 
@@ -804,7 +804,7 @@ static int digi_set_modem_signals(struct usb_serial_port *port,
        spin_unlock(&port_priv->dp_port_lock);
        spin_unlock_irqrestore(&oob_priv->dp_port_lock, flags);
        if (ret)
-               err("%s: usb_submit_urb failed, ret=%d", __FUNCTION__, ret);
+               err("%s: usb_submit_urb failed, ret=%d", __func__, ret);
        return ret;
 }
 
@@ -897,7 +897,7 @@ static void digi_rx_unthrottle(struct usb_serial_port *port)
 
        if (ret)
                err("%s: usb_submit_urb failed, ret=%d, port=%d",
-                       __FUNCTION__, ret, priv->dp_port_num);
+                       __func__, ret, priv->dp_port_num);
 }
 
 
@@ -1107,7 +1107,7 @@ static int digi_tiocmget(struct usb_serial_port *port, struct file *file)
        unsigned int val;
        unsigned long flags;
 
-       dbg("%s: TOP: port=%d", __FUNCTION__, priv->dp_port_num);
+       dbg("%s: TOP: port=%d", __func__, priv->dp_port_num);
 
        spin_lock_irqsave(&priv->dp_port_lock, flags);
        val = priv->dp_modem_signals;
@@ -1123,7 +1123,7 @@ static int digi_tiocmset(struct usb_serial_port *port, struct file *file,
        unsigned int val;
        unsigned long flags;
 
-       dbg("%s: TOP: port=%d", __FUNCTION__, priv->dp_port_num);
+       dbg("%s: TOP: port=%d", __func__, priv->dp_port_num);
 
        spin_lock_irqsave(&priv->dp_port_lock, flags);
        val = (priv->dp_modem_signals & ~clear) | set;
@@ -1218,7 +1218,7 @@ static int digi_write(struct usb_serial_port *port, const unsigned char *buf, in
        spin_unlock_irqrestore(&priv->dp_port_lock, flags);
        if (ret < 0)
                err("%s: usb_submit_urb failed, ret=%d, port=%d",
-                       __FUNCTION__, ret, priv->dp_port_num);
+                       __func__, ret, priv->dp_port_num);
        dbg("digi_write: returning %d", ret);
        return ret;
 
@@ -1239,13 +1239,13 @@ static void digi_write_bulk_callback(struct urb *urb)
        /* port and serial sanity check */
        if (port == NULL || (priv=usb_get_serial_port_data(port)) == NULL) {
                err("%s: port or port->private is NULL, status=%d",
-                   __FUNCTION__, status);
+                   __func__, status);
                return;
        }
        serial = port->serial;
        if (serial == NULL || (serial_priv=usb_get_serial_data(serial)) == NULL) {
                err("%s: serial or serial->private is NULL, status=%d",
-                   __FUNCTION__, status);
+                   __func__, status);
                return;
        }
 
@@ -1286,7 +1286,7 @@ static void digi_write_bulk_callback(struct urb *urb)
        spin_unlock(&priv->dp_port_lock);
        if (ret)
                err("%s: usb_submit_urb failed, ret=%d, port=%d",
-                       __FUNCTION__, ret, priv->dp_port_num);
+                       __func__, ret, priv->dp_port_num);
 }
 
 static int digi_write_room(struct usb_serial_port *port)
@@ -1515,7 +1515,7 @@ static int digi_startup_device(struct usb_serial *serial)
                port->write_urb->dev = port->serial->dev;
                if ((ret = usb_submit_urb(port->read_urb, GFP_KERNEL)) != 0) {
                        err("%s: usb_submit_urb failed, ret=%d, port=%d",
-                             &nb