[PATCH] USB: isp116x-hcd: cleanup
Olav Kongas [Thu, 3 Nov 2005 15:38:14 +0000 (17:38 +0200)]
The attached patch makes a cleanup of isp116x-hcd. Most of the volume of
the patch comes from 2 sources: moving the code around to get rid of a
few function prototypes and reworking register dumping functions/macros.
Among other things, switched over from using procfs to debugfs.

Cleanup. The following changes were made:

- Rework register dumping code so it can be used for dumping
  to both syslog and debugfs.
- Switch from procfs to debugfs..
- Die gracefully on Unrecoverable Error interrupt.
- Fix memory leak in isp116x_urb_enqueue(), if HC happens to
  die in a narrow time window.
- Fix a 'sparce' warning (unnecessary cast).
- Report Devices Removable for root hub ports by default
  (was Devices Permanently Attached).
- Move bus suspend/resume functions down in code to get rid of
  a few function prototypes.
- A number of one-line cleanups.
- Add an entry to MAINTAINERS.

Signed-off-by: Olav Kongas <ok@artecdesign.ee>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

 MAINTAINERS                    |    6
 drivers/usb/host/isp116x-hcd.c |  429 ++++++++++++++++-------------------------
 drivers/usb/host/isp116x.h     |   83 +++++--
 3 files changed, 230 insertions(+), 288 deletions(-)

MAINTAINERS
drivers/usb/host/isp116x-hcd.c
drivers/usb/host/isp116x.h

index 6af6830..861d297 100644 (file)
@@ -2640,6 +2640,12 @@ L:       linux-usb-users@lists.sourceforge.net
 L:     linux-usb-devel@lists.sourceforge.net
 S:     Maintained
 
+USB ISP116X DRIVER
+P:     Olav Kongas
+M:     ok@artecdesign.ee
+L:     linux-usb-devel@lists.sourceforge.net
+S:     Maintained
+
 USB KAWASAKI LSI DRIVER
 P:     Oliver Neukum
 M:     oliver@neukum.name
index 5f56c4a..342cfad 100644 (file)
 /* enqueuing/finishing log of urbs */
 //#define URB_TRACE
 
-#include <linux/config.h>
 #include <linux/module.h>
-#include <linux/moduleparam.h>
-#include <linux/kernel.h>
 #include <linux/delay.h>
-#include <linux/ioport.h>
-#include <linux/sched.h>
-#include <linux/slab.h>
-#include <linux/smp_lock.h>
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/list.h>
-#include <linux/interrupt.h>
 #include <linux/usb.h>
 #include <linux/usb_isp116x.h>
 #include <linux/platform_device.h>
 #include <asm/system.h>
 #include <asm/byteorder.h>
 
-#ifndef DEBUG
-#      define  STUB_DEBUG_FILE
-#endif
-
 #include "../core/hcd.h"
 #include "isp116x.h"
 
-#define DRIVER_VERSION "05 Aug 2005"
+#define DRIVER_VERSION "03 Nov 2005"
 #define DRIVER_DESC    "ISP116x USB Host Controller Driver"
 
 MODULE_DESCRIPTION(DRIVER_DESC);
@@ -305,9 +295,8 @@ static void postproc_atl_queue(struct isp116x *isp116x)
                udev = urb->dev;
                ptd = &ep->ptd;
                cc = PTD_GET_CC(ptd);
-
-               spin_lock(&urb->lock);
                short_not_ok = 1;
+               spin_lock(&urb->lock);
 
                /* Data underrun is special. For allowed underrun
                   we clear the error and continue as normal. For
@@ -420,7 +409,7 @@ static void postproc_atl_queue(struct isp116x *isp116x)
                        ep->nextpid = 0;
                        break;
                default:
-                       BUG_ON(1);
+                       BUG();
                }
                spin_unlock(&urb->lock);
        }
@@ -628,8 +617,12 @@ static irqreturn_t isp116x_irq(struct usb_hcd *hcd, struct pt_regs *regs)
                u32 intstat = isp116x_read_reg32(isp116x, HCINTSTAT);
                isp116x_write_reg32(isp116x, HCINTSTAT, intstat);
                if (intstat & HCINT_UE) {
-                       ERR("Unrecoverable error\n");
-                       /* What should we do here? Reset?  */
+                       ERR("Unrecoverable error, HC is dead!\n");
+                       /* IRQ's are off, we do no DMA,
+                          perfectly ready to die ... */
+                       hcd->state = HC_STATE_HALT;
+                       ret = IRQ_HANDLED;
+                       goto done;
                }
                if (intstat & HCINT_RHSC)
                        /* When root hub or any of its ports is going
@@ -640,7 +633,6 @@ static irqreturn_t isp116x_irq(struct usb_hcd *hcd, struct pt_regs *regs)
                if (intstat & HCINT_RD) {
                        DBG("---- remote wakeup\n");
                        usb_hcd_resume_root_hub(hcd);
-                       ret = IRQ_HANDLED;
                }
                irqstat &= ~HCuPINT_OPR;
                ret = IRQ_HANDLED;
@@ -651,6 +643,7 @@ static irqreturn_t isp116x_irq(struct usb_hcd *hcd, struct pt_regs *regs)
        }
 
        isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb);
+      done:
        spin_unlock(&isp116x->lock);
        return ret;
 }
@@ -724,6 +717,7 @@ static int isp116x_urb_enqueue(struct usb_hcd *hcd,
 
        spin_lock_irqsave(&isp116x->lock, flags);
        if (!HC_IS_RUNNING(hcd->state)) {
+               kfree(ep);
                ret = -ENODEV;
                goto fail;
        }
@@ -888,7 +882,7 @@ static void isp116x_endpoint_disable(struct usb_hcd *hcd,
                                     struct usb_host_endpoint *hep)
 {
        int i;
-       struct isp116x_ep *ep = hep->hcpriv;;
+       struct isp116x_ep *ep = hep->hcpriv;
 
        if (!ep)
                return;
@@ -916,8 +910,6 @@ static int isp116x_get_frame(struct usb_hcd *hcd)
        return (int)fmnum;
 }
 
-/*----------------------------------------------------------------*/
-
 /*
   Adapted from ohci-hub.c. Currently we don't support autosuspend.
 */
@@ -968,11 +960,10 @@ static void isp116x_hub_descriptor(struct isp116x *isp116x,
        desc->bHubContrCurrent = 0;
        desc->bNbrPorts = (u8) (reg & 0x3);
        /* Power switching, device type, overcurrent. */
-       desc->wHubCharacteristics =
-           (__force __u16) cpu_to_le16((u16) ((reg >> 8) & 0x1f));
+       desc->wHubCharacteristics = cpu_to_le16((u16) ((reg >> 8) & 0x1f));
        desc->bPwrOn2PwrGood = (u8) ((reg >> 24) & 0xff);
        /* two bitmaps:  ports removable, and legacy PortPwrCtrlMask */
-       desc->bitmap[0] = desc->bNbrPorts == 1 ? 1 << 1 : 3 << 1;
+       desc->bitmap[0] = 0;
        desc->bitmap[1] = ~0;
 }
 
@@ -1159,145 +1150,9 @@ static int isp116x_hub_control(struct usb_hcd *hcd,
        return ret;
 }
 
-#ifdef CONFIG_PM
-
-static int isp116x_bus_suspend(struct usb_hcd *hcd)
-{
-       struct isp116x *isp116x = hcd_to_isp116x(hcd);
-       unsigned long flags;
-       u32 val;
-       int ret = 0;
-
-       spin_lock_irqsave(&isp116x->lock, flags);
-
-       val = isp116x_read_reg32(isp116x, HCCONTROL);
-       switch (val & HCCONTROL_HCFS) {
-       case HCCONTROL_USB_OPER:
-               hcd->state = HC_STATE_QUIESCING;
-               val &= (~HCCONTROL_HCFS & ~HCCONTROL_RWE);
-               val |= HCCONTROL_USB_SUSPEND;
-               if (hcd->remote_wakeup)
-                       val |= HCCONTROL_RWE;
-               /* Wait for usb transfers to finish */
-               mdelay(2);
-               isp116x_write_reg32(isp116x, HCCONTROL, val);
-               hcd->state = HC_STATE_SUSPENDED;
-               /* Wait for devices to suspend */
-               mdelay(5);
-       case HCCONTROL_USB_SUSPEND:
-               break;
-       case HCCONTROL_USB_RESUME:
-               isp116x_write_reg32(isp116x, HCCONTROL,
-                                   (val & ~HCCONTROL_HCFS) |
-                                   HCCONTROL_USB_RESET);
-       case HCCONTROL_USB_RESET:
-               ret = -EBUSY;
-               break;
-       default:
-               ret = -EINVAL;
-       }
-
-       spin_unlock_irqrestore(&isp116x->lock, flags);
-       return ret;
-}
-
-/* Get rid of these declarations later in cleanup */
-static int isp116x_reset(struct usb_hcd *hcd);
-static int isp116x_start(struct usb_hcd *hcd);
-
-static int isp116x_bus_resume(struct usb_hcd *hcd)
-{
-       struct isp116x *isp116x = hcd_to_isp116x(hcd);
-       u32 val;
-
-       msleep(5);
-       spin_lock_irq(&isp116x->lock);
-
-       val = isp116x_read_reg32(isp116x, HCCONTROL);
-       switch (val & HCCONTROL_HCFS) {
-       case HCCONTROL_USB_SUSPEND:
-               val &= ~HCCONTROL_HCFS;
-               val |= HCCONTROL_USB_RESUME;
-               isp116x_write_reg32(isp116x, HCCONTROL, val);
-       case HCCONTROL_USB_RESUME:
-               break;
-       case HCCONTROL_USB_OPER:
-               spin_unlock_irq(&isp116x->lock);
-               /* Without setting power_state here the
-                  SUSPENDED state won't be removed from
-                  sysfs/usbN/power.state as a response to remote
-                  wakeup. Maybe in the future. */
-               hcd->self.root_hub->dev.power.power_state = PMSG_ON;
-               return 0;
-       default:
-               /* HCCONTROL_USB_RESET: this may happen, when during
-                  suspension the HC lost power. Reinitialize completely */
-               spin_unlock_irq(&isp116x->lock);
-               DBG("Chip has been reset while suspended. Reinit from scratch.\n");
-               isp116x_reset(hcd);
-               isp116x_start(hcd);
-               isp116x_hub_control(hcd, SetPortFeature,
-                                   USB_PORT_FEAT_POWER, 1, NULL, 0);
-               if ((isp116x->rhdesca & RH_A_NDP) == 2)
-                       isp116x_hub_control(hcd, SetPortFeature,
-                                           USB_PORT_FEAT_POWER, 2, NULL, 0);
-               hcd->self.root_hub->dev.power.power_state = PMSG_ON;
-               return 0;
-       }
-
-       val = isp116x->rhdesca & RH_A_NDP;
-       while (val--) {
-               u32 stat =
-                   isp116x_read_reg32(isp116x, val ? HCRHPORT2 : HCRHPORT1);
-               /* force global, not selective, resume */
-               if (!(stat & RH_PS_PSS))
-                       continue;
-               DBG("%s: Resuming port %d\n", __func__, val);
-               isp116x_write_reg32(isp116x, RH_PS_POCI, val
-                                   ? HCRHPORT2 : HCRHPORT1);
-       }
-       spin_unlock_irq(&isp116x->lock);
-
-       hcd->state = HC_STATE_RESUMING;
-       mdelay(20);
-
-       /* Go operational */
-       spin_lock_irq(&isp116x->lock);
-       val = isp116x_read_reg32(isp116x, HCCONTROL);
-       isp116x_write_reg32(isp116x, HCCONTROL,
-                           (val & ~HCCONTROL_HCFS) | HCCONTROL_USB_OPER);
-       spin_unlock_irq(&isp116x->lock);
-       /* see analogous comment above */
-       hcd->self.root_hub->dev.power.power_state = PMSG_ON;
-       hcd->state = HC_STATE_RUNNING;
-
-       return 0;
-}
-
-
-#else
-
-#define        isp116x_bus_suspend     NULL
-#define        isp116x_bus_resume      NULL
-
-#endif
-
 /*-----------------------------------------------------------------*/
 
-#ifdef STUB_DEBUG_FILE
-
-static inline void create_debug_file(struct isp116x *isp116x)
-{
-}
-
-static inline void remove_debug_file(struct isp116x *isp116x)
-{
-}
-
-#else
-
-#include <linux/proc_fs.h>
-#include <linux/seq_file.h>
+#ifdef CONFIG_DEBUG_FS
 
 static void dump_irq(struct seq_file *s, char *label, u16 mask)
 {
@@ -1321,13 +1176,9 @@ static void dump_int(struct seq_file *s, char *label, u32 mask)
                   mask & HCINT_SF ? " sof" : "", mask & HCINT_SO ? " so" : "");
 }
 
-static int proc_isp116x_show(struct seq_file *s, void *unused)
+static int isp116x_show_dbg(struct seq_file *s, void *unused)
 {
        struct isp116x *isp116x = s->private;
-       struct isp116x_ep *ep;
-       struct urb *urb;
-       unsigned i;
-       char *str;
 
        seq_printf(s, "%s\n%s version %s\n",
                   isp116x_to_hcd(isp116x)->product_desc, hcd_name,
@@ -1343,105 +1194,50 @@ static int proc_isp116x_show(struct seq_file *s, void *unused)
        }
 
        spin_lock_irq(&isp116x->lock);
-
        dump_irq(s, "hc_irq_enable", isp116x_read_reg16(isp116x, HCuPINTENB));
        dump_irq(s, "hc_irq_status", isp116x_read_reg16(isp116x, HCuPINT));
        dump_int(s, "hc_int_enable", isp116x_read_reg32(isp116x, HCINTENB));
        dump_int(s, "hc_int_status", isp116x_read_reg32(isp116x, HCINTSTAT));
-
-       list_for_each_entry(ep, &isp116x->async, schedule) {
-
-               switch (ep->nextpid) {
-               case USB_PID_IN:
-                       str = "in";
-                       break;
-               case USB_PID_OUT:
-                       str = "out";
-                       break;
-               case USB_PID_SETUP:
-                       str = "setup";
-                       break;
-               case USB_PID_ACK:
-                       str = "status";
-                       break;
-               default:
-                       str = "?";
-                       break;
-               };
-               seq_printf(s, "%p, ep%d%s, maxpacket %d:\n", ep,
-                          ep->epnum, str, ep->maxpacket);
-               list_for_each_entry(urb, &ep->hep->urb_list, urb_list) {
-                       seq_printf(s, "  urb%p, %d/%d\n", urb,
-                                  urb->actual_length,
-                                  urb->transfer_buffer_length);
-               }
-       }
-       if (!list_empty(&isp116x->async))
-               seq_printf(s, "\n");
-
-       seq_printf(s, "periodic size= %d\n", PERIODIC_SIZE);
-
-       for (i = 0; i < PERIODIC_SIZE; i++) {
-               ep = isp116x->periodic[i];
-               if (!ep)
-                       continue;
-               seq_printf(s, "%2d [%3d]:\n", i, isp116x->load[i]);
-
-               /* DUMB: prints shared entries multiple times */
-               do {
-                       seq_printf(s, "   %d/%p (%sdev%d ep%d%s max %d)\n",
-                                  ep->period, ep,
-                                  (ep->udev->speed ==
-                                   USB_SPEED_FULL) ? "" : "ls ",
-                                  ep->udev->devnum, ep->epnum,
-                                  (ep->epnum ==
-                                   0) ? "" : ((ep->nextpid ==
-                                               USB_PID_IN) ? "in" : "out"),
-                                  ep->maxpacket);
-                       ep = ep->next;
-               } while (ep);
-       }
+       isp116x_show_regs_seq(isp116x, s);
        spin_unlock_irq(&isp116x->lock);
        seq_printf(s, "\n");
 
        return 0;
 }
 
-static int proc_isp116x_open(struct inode *inode, struct file *file)
+static int isp116x_open_seq(struct inode *inode, struct file *file)
 {
-       return single_open(file, proc_isp116x_show, PDE(inode)->data);
+       return single_open(file, isp116x_show_dbg, inode->u.generic_ip);
 }
 
-static struct file_operations proc_ops = {
-       .open = proc_isp116x_open,
+static struct file_operations isp116x_debug_fops = {
+       .open = isp116x_open_seq,
        .read = seq_read,
        .llseek = seq_lseek,
        .release = single_release,
 };
 
-/* expect just one isp116x per system */
-static const char proc_filename[] = "driver/isp116x";
-
-static void create_debug_file(struct isp116x *isp116x)
+static int create_debug_file(struct isp116x *isp116x)
 {
-       struct proc_dir_entry *pde;
-
-       pde = create_proc_entry(proc_filename, 0, NULL);
-       if (pde == NULL)
-               return;
-
-       pde->proc_fops = &proc_ops;
-       pde->data = isp116x;
-       isp116x->pde = pde;
+       isp116x->dentry = debugfs_create_file(hcd_name,
+                                             S_IRUGO, NULL, isp116x,
+                                             &isp116x_debug_fops);
+       if (!isp116x->dentry)
+               return -ENOMEM;
+       return 0;
 }
 
 static void remove_debug_file(struct isp116x *isp116x)
 {
-       if (isp116x->pde)
-               remove_proc_entry(proc_filename, NULL);
+       debugfs_remove(isp116x->dentry);
 }
 
-#endif
+#else
+
+#define        create_debug_file(d)    0
+#define        remove_debug_file(d)    do{}while(0)
+
+#endif                         /* CONFIG_DEBUG_FS */
 
 /*-----------------------------------------------------------------*/
 
@@ -1476,7 +1272,7 @@ static int isp116x_reset(struct usb_hcd *hcd)
        struct isp116x *isp116x = hcd_to_isp116x(hcd);
        unsigned long t;
        u16 clkrdy = 0;
-       int ret = 0, timeout = 15 /* ms */ ;
+       int ret, timeout = 15 /* ms */ ;
 
        ret = isp116x_sw_reset(isp116x);
        if (ret)
@@ -1492,7 +1288,7 @@ static int isp116x_reset(struct usb_hcd *hcd)
                        break;
        }
        if (!clkrdy) {
-               ERR("Clock not ready after 20ms\n");
+               ERR("Clock not ready after %dms\n", timeout);
                /* After sw_reset the clock won't report to be ready, if
                   H_WAKEUP pin is high. */
                ERR("Please make sure that the H_WAKEUP pin is pulled low!\n");
@@ -1610,12 +1406,128 @@ static int isp116x_start(struct usb_hcd *hcd)
        isp116x_write_reg32(isp116x, HCRHPORT1, RH_PS_CCS);
        isp116x_write_reg32(isp116x, HCRHPORT2, RH_PS_CCS);
 
-       isp116x_show_regs(isp116x);
+       isp116x_show_regs_log(isp116x);
        spin_unlock_irqrestore(&isp116x->lock, flags);
        return 0;
 }
 
-/*-----------------------------------------------------------------*/
+#ifdef CONFIG_PM
+
+static int isp116x_bus_suspend(struct usb_hcd *hcd)
+{
+       struct isp116x *isp116x = hcd_to_isp116x(hcd);
+       unsigned long flags;
+       u32 val;
+       int ret = 0;
+
+       spin_lock_irqsave(&isp116x->lock, flags);
+
+       val = isp116x_read_reg32(isp116x, HCCONTROL);
+       switch (val & HCCONTROL_HCFS) {
+       case HCCONTROL_USB_OPER:
+               hcd->state = HC_STATE_QUIESCING;
+               val &= (~HCCONTROL_HCFS & ~HCCONTROL_RWE);
+               val |= HCCONTROL_USB_SUSPEND;
+               if (hcd->remote_wakeup)
+                       val |= HCCONTROL_RWE;
+               /* Wait for usb transfers to finish */
+               mdelay(2);
+               isp116x_write_reg32(isp116x, HCCONTROL, val);
+               hcd->state = HC_STATE_SUSPENDED;
+               /* Wait for devices to suspend */
+               mdelay(5);
+       case HCCONTROL_USB_SUSPEND:
+               break;
+       case HCCONTROL_USB_RESUME:
+               isp116x_write_reg32(isp116x, HCCONTROL,
+                                   (val & ~HCCONTROL_HCFS) |
+                                   HCCONTROL_USB_RESET);
+       case HCCONTROL_USB_RESET:
+               ret = -EBUSY;
+               break;
+       default:
+               ret = -EINVAL;
+       }
+
+       spin_unlock_irqrestore(&isp116x->lock, flags);
+       return ret;
+}
+
+static int isp116x_bus_resume(struct usb_hcd *hcd)
+{
+       struct isp116x *isp116x = hcd_to_isp116x(hcd);
+       u32 val;
+
+       msleep(5);
+       spin_lock_irq(&isp116x->lock);
+
+       val = isp116x_read_reg32(isp116x, HCCONTROL);
+       switch (val & HCCONTROL_HCFS) {
+       case HCCONTROL_USB_SUSPEND:
+               val &= ~HCCONTROL_HCFS;
+               val |= HCCONTROL_USB_RESUME;
+               isp116x_write_reg32(isp116x, HCCONTROL, val);
+       case HCCONTROL_USB_RESUME:
+               break;
+       case HCCONTROL_USB_OPER:
+               spin_unlock_irq(&isp116x->lock);
+               /* Without setting power_state here the
+                  SUSPENDED state won't be removed from
+                  sysfs/usbN/power.state as a response to remote
+                  wakeup. Maybe in the future. */
+               hcd->self.root_hub->dev.power.power_state = PMSG_ON;
+               return 0;
+       default:
+               /* HCCONTROL_USB_RESET: this may happen, when during
+                  suspension the HC lost power. Reinitialize completely */
+               spin_unlock_irq(&isp116x->lock);
+               DBG("Chip has been reset while suspended. Reinit from scratch.\n");
+               isp116x_reset(hcd);
+               isp116x_start(hcd);
+               isp116x_hub_control(hcd, SetPortFeature,
+                                   USB_PORT_FEAT_POWER, 1, NULL, 0);
+               if ((isp116x->rhdesca & RH_A_NDP) == 2)
+                       isp116x_hub_control(hcd, SetPortFeature,
+                                           USB_PORT_FEAT_POWER, 2, NULL, 0);
+               hcd->self.root_hub->dev.power.power_state = PMSG_ON;
+               return 0;
+       }
+
+       val = isp116x->rhdesca & RH_A_NDP;
+       while (val--) {
+               u32 stat =
+                   isp116x_read_reg32(isp116x, val ? HCRHPORT2 : HCRHPORT1);
+               /* force global, not selective, resume */
+               if (!(stat & RH_PS_PSS))
+                       continue;
+               DBG("%s: Resuming port %d\n", __func__, val);
+               isp116x_write_reg32(isp116x, RH_PS_POCI, val
+                                   ? HCRHPORT2 : HCRHPORT1);
+       }
+       spin_unlock_irq(&isp116x->lock);
+
+       hcd->state = HC_STATE_RESUMING;
+       msleep(20);
+
+       /* Go operational */
+       spin_lock_irq(&isp116x->lock);
+       val = isp116x_read_reg32(isp116x, HCCONTROL);
+       isp116x_write_reg32(isp116x, HCCONTROL,
+                           (val & ~HCCONTROL_HCFS) | HCCONTROL_USB_OPER);
+       spin_unlock_irq(&isp116x->lock);
+       /* see analogous comment above */
+       hcd->self.root_hub->dev.power.power_state = PMSG_ON;
+       hcd->state = HC_STATE_RUNNING;
+
+       return 0;
+}
+
+#else
+
+#define        isp116x_bus_suspend     NULL
+#define        isp116x_bus_resume      NULL
+
+#endif
 
 static struct hc_driver isp116x_hc_driver = {
        .description = hcd_name,
@@ -1745,12 +1657,19 @@ static int __init isp116x_probe(struct platform_device *pdev)
        }
 
        ret = usb_add_hcd(hcd, irq, SA_INTERRUPT);
-       if (ret != 0)
+       if (ret)
                goto err6;
 
-       create_debug_file(isp116x);
+       ret = create_debug_file(isp116x);
+       if (ret) {
+               ERR("Couldn't create debugfs entry\n");
+               goto err7;
+       }
+
        return 0;
 
+      err7:
+       usb_remove_hcd(hcd);
       err6:
        usb_put_hcd(hcd);
       err5:
@@ -1772,13 +1691,9 @@ static int __init isp116x_probe(struct platform_device *pdev)
 */
 static int isp116x_suspend(struct platform_device *dev, pm_message_t state)
 {
-       int ret = 0;
-
-       VDBG("%s: state %x\n", __func__, state);
-
+       VDBG("%s: state %x\n", __func__, state.event);
        dev->dev.power.power_state = state;
-
-       return ret;
+       return 0;
 }
 
 /*
@@ -1786,13 +1701,9 @@ static int isp116x_suspend(struct platform_device *dev, pm_message_t state)
 */
 static int isp116x_resume(struct platform_device *dev)
 {
-       int ret = 0;
-
-       VDBG("%s:  state %x\n", __func__, dev->dev.power.power_state);
-
+       VDBG("%s:  state %x\n", __func__, dev->power.power_state.event);
        dev->dev.power.power_state = PMSG_ON;
-
-       return ret;
+       return 0;
 }
 
 #else
index c6fec96..a1b7c38 100644 (file)
@@ -259,7 +259,7 @@ struct isp116x {
 
        struct isp116x_platform_data *board;
 
-       struct proc_dir_entry *pde;
+       struct dentry *dentry;
        unsigned long stat1, stat2, stat4, stat8, stat16;
 
        /* HC registers */
@@ -450,7 +450,7 @@ static void isp116x_write_reg32(struct isp116x *isp116x, unsigned reg,
        isp116x_write_data32(isp116x, (u32) val);
 }
 
-#define isp116x_show_reg(d,r) {                                        \
+#define isp116x_show_reg_log(d,r,s) {                          \
        if ((r) < 0x20) {                                       \
                DBG("%-12s[%02x]: %08x\n", #r,                  \
                        r, isp116x_read_reg32(d, r));           \
@@ -459,35 +459,60 @@ static void isp116x_write_reg32(struct isp116x *isp116x, unsigned reg,
                        r, isp116x_read_reg16(d, r));           \
        }                                                       \
 }
+#define isp116x_show_reg_seq(d,r,s) {                          \
+       if ((r) < 0x20) {                                       \
+               seq_printf(s, "%-12s[%02x]: %08x\n", #r,        \
+                       r, isp116x_read_reg32(d, r));           \
+       } else {                                                \
+               seq_printf(s, "%-12s[%02x]:     %04x\n", #r,    \
+                       r, isp116x_read_reg16(d, r));           \
+       }                                                       \
+}
 
-static inline void isp116x_show_regs(struct isp116x *isp116x)
+#define isp116x_show_regs(d,type,s) {                  \
+       isp116x_show_reg_##type(d, HCREVISION, s);      \
+       isp116x_show_reg_##type(d, HCCONTROL, s);       \
+       isp116x_show_reg_##type(d, HCCMDSTAT, s);       \
+       isp116x_show_reg_##type(d, HCINTSTAT, s);       \
+       isp116x_show_reg_##type(d, HCINTENB, s);        \
+       isp116x_show_reg_##type(d, HCFMINTVL, s);       \
+       isp116x_show_reg_##type(d, HCFMREM, s);         \
+       isp116x_show_reg_##type(d, HCFMNUM, s);         \
+       isp116x_show_reg_##type(d, HCLSTHRESH, s);      \
+       isp116x_show_reg_##type(d, HCRHDESCA, s);       \
+       isp116x_show_reg_##type(d, HCRHDESCB, s);       \
+       isp116x_show_reg_##type(d, HCRHSTATUS, s);      \
+       isp116x_show_reg_##type(d, HCRHPORT1, s);       \
+       isp116x_show_reg_##type(d, HCRHPORT2, s);       \
+       isp116x_show_reg_##type(d, HCHWCFG, s);         \
+       isp116x_show_reg_##type(d, HCDMACFG, s);        \
+       isp116x_show_reg_##type(d, HCXFERCTR, s);       \
+       isp116x_show_reg_##type(d, HCuPINT, s);         \
+       isp116x_show_reg_##type(d, HCuPINTENB, s);      \
+       isp116x_show_reg_##type(d, HCCHIPID, s);        \
+       isp116x_show_reg_##type(d, HCSCRATCH, s);       \
+       isp116x_show_reg_##type(d, HCITLBUFLEN, s);     \
+       isp116x_show_reg_##type(d, HCATLBUFLEN, s);     \
+       isp116x_show_reg_##type(d, HCBUFSTAT, s);       \
+       isp116x_show_reg_##type(d, HCRDITL0LEN, s);     \
+       isp116x_show_reg_##type(d, HCRDITL1LEN, s);     \
+}
+
+/*
+   Dump registers for debugfs.
+*/
+static inline void isp116x_show_regs_seq(struct isp116x *isp116x,
+                                         struct seq_file *s)
+{
+       isp116x_show_regs(isp116x, seq, s);
+}
+
+/*
+   Dump registers to syslog.
+*/
+static inline void isp116x_show_regs_log(struct isp116x *isp116x)
 {
-       isp116x_show_reg(isp116x, HCREVISION);
-       isp116x_show_reg(isp116x, HCCONTROL);
-       isp116x_show_reg(isp116x, HCCMDSTAT);
-       isp116x_show_reg(isp116x, HCINTSTAT);
-       isp116x_show_reg(isp116x, HCINTENB);
-       isp116x_show_reg(isp116x, HCFMINTVL);
-       isp116x_show_reg(isp116x, HCFMREM);
-       isp116x_show_reg(isp116x, HCFMNUM);
-       isp116x_show_reg(isp116x, HCLSTHRESH);
-       isp116x_show_reg(isp116x, HCRHDESCA);
-       isp116x_show_reg(isp116x, HCRHDESCB);
-       isp116x_show_reg(isp116x, HCRHSTATUS);
-       isp116x_show_reg(isp116x, HCRHPORT1);
-       isp116x_show_reg(isp116x, HCRHPORT2);
-       isp116x_show_reg(isp116x, HCHWCFG);
-       isp116x_show_reg(isp116x, HCDMACFG);
-       isp116x_show_reg(isp116x, HCXFERCTR);
-       isp116x_show_reg(isp116x, HCuPINT);
-       isp116x_show_reg(isp116x, HCuPINTENB);
-       isp116x_show_reg(isp116x, HCCHIPID);
-       isp116x_show_reg(isp116x, HCSCRATCH);
-       isp116x_show_reg(isp116x, HCITLBUFLEN);
-       isp116x_show_reg(isp116x, HCATLBUFLEN);
-       isp116x_show_reg(isp116x, HCBUFSTAT);
-       isp116x_show_reg(isp116x, HCRDITL0LEN);
-       isp116x_show_reg(isp116x, HCRDITL1LEN);
+       isp116x_show_regs(isp116x, log, NULL);
 }
 
 #if defined(URB_TRACE)