diff options
| author | Greg Kroah-Hartman <gregkh@linuxfoundation.org> | 2013-07-24 14:45:58 -0700 |
|---|---|---|
| committer | Greg Kroah-Hartman <gregkh@linuxfoundation.org> | 2013-07-24 14:45:58 -0700 |
| commit | 6866d52ad99a8c2c5301c7371fce365d25b2d0be (patch) | |
| tree | f39adaa4087fd91ed21e7fd81c09ace7b2d9228d /applied | |
| parent | e275d064f56be8b9dec6fc2e33d6b075dcc2ac62 (diff) | |
| download | patches-6866d52ad99a8c2c5301c7371fce365d25b2d0be.tar.gz | |
move applied patches to applied/ and add a pwm patch
Diffstat (limited to 'applied')
28 files changed, 3018 insertions, 0 deletions
diff --git a/applied/misc-c2port-use-dev_bin_attrs-instead-of-hand-coding-it.patch b/applied/misc-c2port-use-dev_bin_attrs-instead-of-hand-coding-it.patch new file mode 100644 index 00000000000000..79a279f1d14c21 --- /dev/null +++ b/applied/misc-c2port-use-dev_bin_attrs-instead-of-hand-coding-it.patch @@ -0,0 +1,93 @@ +From foo@baz Mon Jul 8 11:31:26 PDT 2013 +Date: Mon, 08 Jul 2013 11:31:26 -0700 +To: Greg KH <gregkh@linuxfoundation.org> +From: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +Subject: [PATCH] misc: c2port: use dev_bin_attrs instead of hand-coding it + +From: Greg Kroah-Hartman <gregkh@linuxfoundation.org> + +Classes support a list of default binary attributes, so use that in the +c2port driver, instead of hand creating and destroying the file, which +is racing with userspace. Bonus is this removes lines of code. + +Cc: Rodolfo Giometti <giometti@linux.it> +Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +-- + drivers/misc/c2port/core.c | 30 +++++++++++++----------------- + 1 file changed, 13 insertions(+), 17 deletions(-) + +--- a/drivers/misc/c2port/core.c ++++ b/drivers/misc/c2port/core.c +@@ -867,14 +867,17 @@ static struct device_attribute c2port_at + __ATTR_NULL, + }; + +-static struct bin_attribute c2port_bin_attrs = { +- .attr = { +- .name = "flash_data", +- .mode = 0644 ++static struct bin_attribute c2port_bin_attrs[] = { ++ { ++ .attr = { ++ .name = "flash_data", ++ .mode = 0644 ++ }, ++ .read = c2port_read_flash_data, ++ .write = c2port_write_flash_data, ++ /* .size is computed at run-time */ + }, +- .read = c2port_read_flash_data, +- .write = c2port_write_flash_data, +- /* .size is computed at run-time */ ++ __ATTR_NULL + }; + + /* +@@ -907,6 +910,8 @@ struct c2port_device *c2port_device_regi + goto error_idr_alloc; + c2dev->id = ret; + ++ c2port_bin_attrs[0].size = ops->blocks_num * ops->block_size; ++ + c2dev->dev = device_create(c2port_class, NULL, 0, c2dev, + "c2port%d", c2dev->id); + if (unlikely(IS_ERR(c2dev->dev))) { +@@ -919,12 +924,6 @@ struct c2port_device *c2port_device_regi + c2dev->ops = ops; + mutex_init(&c2dev->mutex); + +- /* Create binary file */ +- c2port_bin_attrs.size = ops->blocks_num * ops->block_size; +- ret = device_create_bin_file(c2dev->dev, &c2port_bin_attrs); +- if (unlikely(ret)) +- goto error_device_create_bin_file; +- + /* By default C2 port access is off */ + c2dev->access = c2dev->flash_access = 0; + ops->access(c2dev, 0); +@@ -937,9 +936,6 @@ struct c2port_device *c2port_device_regi + + return c2dev; + +-error_device_create_bin_file: +- device_destroy(c2port_class, 0); +- + error_device_create: + spin_lock_irq(&c2port_idr_lock); + idr_remove(&c2port_idr, c2dev->id); +@@ -959,7 +955,6 @@ void c2port_device_unregister(struct c2p + + dev_info(c2dev->dev, "C2 port %s removed\n", c2dev->name); + +- device_remove_bin_file(c2dev->dev, &c2port_bin_attrs); + spin_lock_irq(&c2port_idr_lock); + idr_remove(&c2port_idr, c2dev->id); + spin_unlock_irq(&c2port_idr_lock); +@@ -985,6 +980,7 @@ static int __init c2port_init(void) + return PTR_ERR(c2port_class); + } + c2port_class->dev_attrs = c2port_attrs; ++ c2port_class->dev_bin_attrs = c2port_bin_attrs; + + return 0; + } diff --git a/applied/usb-adutux-remove-custom-debug-macro-and-module-parameter.patch b/applied/usb-adutux-remove-custom-debug-macro-and-module-parameter.patch new file mode 100644 index 00000000000000..5677c3185c92f4 --- /dev/null +++ b/applied/usb-adutux-remove-custom-debug-macro-and-module-parameter.patch @@ -0,0 +1,125 @@ +From foo@baz Wed Jun 26 16:22:38 PDT 2013 +Date: Wed, 26 Jun 2013 16:22:38 -0700 +To: Greg KH <gregkh@linuxfoundation.org> +Cc: linux-usb@vger.kernel.org +From: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +Subject: USB: adutux: remove custom debug macro and module parameter + +Now that we don't use the dbg() macro, remove it, and the module +parameter. Also fix up the "dump_data" function to properly use the +dynamic debug core and the correct printk options, and don't call it +twice per function, as the data doesn't change from the beginning and +the end of the call. + +Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> + +--- + drivers/usb/misc/adutux.c | 50 ++++++++-------------------------------------- + 1 file changed, 9 insertions(+), 41 deletions(-) + +--- a/drivers/usb/misc/adutux.c ++++ b/drivers/usb/misc/adutux.c +@@ -27,30 +27,11 @@ + #include <linux/mutex.h> + #include <linux/uaccess.h> + +-#ifdef CONFIG_USB_DEBUG +-static int debug = 5; +-#else +-static int debug = 1; +-#endif +- +-/* Use our own dbg macro */ +-#undef dbg +-#define dbg(lvl, format, arg...) \ +-do { \ +- if (debug >= lvl) \ +- printk(KERN_DEBUG "%s: " format "\n", __FILE__, ##arg); \ +-} while (0) +- +- + /* Version Information */ + #define DRIVER_VERSION "v0.0.13" + #define DRIVER_AUTHOR "John Homppi" + #define DRIVER_DESC "adutux (see www.ontrak.net)" + +-/* Module parameters */ +-module_param(debug, int, S_IRUGO | S_IWUSR); +-MODULE_PARM_DESC(debug, "Debug enabled or not"); +- + /* Define these values to match your device */ + #define ADU_VENDOR_ID 0x0a07 + #define ADU_PRODUCT_ID 0x0064 +@@ -124,19 +105,11 @@ static DEFINE_MUTEX(adutux_mutex); + + static struct usb_driver adu_driver; + +-static void adu_debug_data(int level, const char *function, int size, +- const unsigned char *data) ++static inline void adu_debug_data(struct device *dev, const char *function, ++ int size, const unsigned char *data) + { +- int i; +- +- if (debug < level) +- return; +- +- printk(KERN_DEBUG "%s: %s - length = %d, data = ", +- __FILE__, function, size); +- for (i = 0; i < size; ++i) +- printk("%.2x ", data[i]); +- printk("\n"); ++ dev_dbg(dev, "%s - length = %d, data = %*ph\n", ++ function, size, size, data); + } + + /** +@@ -185,8 +158,8 @@ static void adu_interrupt_in_callback(st + struct adu_device *dev = urb->context; + int status = urb->status; + +- adu_debug_data(5, __func__, urb->actual_length, +- urb->transfer_buffer); ++ adu_debug_data(&dev->udev->dev, __func__, ++ urb->actual_length, urb->transfer_buffer); + + spin_lock(&dev->buflock); + +@@ -222,8 +195,6 @@ exit: + spin_unlock(&dev->buflock); + /* always wake up so we recover from errors */ + wake_up_interruptible(&dev->read_wait); +- adu_debug_data(5, __func__, urb->actual_length, +- urb->transfer_buffer); + } + + static void adu_interrupt_out_callback(struct urb *urb) +@@ -231,7 +202,8 @@ static void adu_interrupt_out_callback(s + struct adu_device *dev = urb->context; + int status = urb->status; + +- adu_debug_data(5, __func__, urb->actual_length, urb->transfer_buffer); ++ adu_debug_data(&dev->udev->dev, __func__, ++ urb->actual_length, urb->transfer_buffer); + + if (status != 0) { + if ((status != -ENOENT) && +@@ -240,17 +212,13 @@ static void adu_interrupt_out_callback(s + "%s :nonzero status received: %d\n", __func__, + status); + } +- goto exit; ++ return; + } + + spin_lock(&dev->buflock); + dev->out_urb_finished = 1; + wake_up(&dev->write_wait); + spin_unlock(&dev->buflock); +-exit: +- +- adu_debug_data(5, __func__, urb->actual_length, +- urb->transfer_buffer); + } + + static int adu_open(struct inode *inode, struct file *file) diff --git a/applied/usb-adutux-remove-custom-debug-macro.patch b/applied/usb-adutux-remove-custom-debug-macro.patch new file mode 100644 index 00000000000000..e8482b5b86b4ee --- /dev/null +++ b/applied/usb-adutux-remove-custom-debug-macro.patch @@ -0,0 +1,283 @@ +From foo@baz Wed Jun 26 16:22:06 PDT 2013 +Date: Wed, 26 Jun 2013 16:22:06 -0700 +To: Greg KH <gregkh@linuxfoundation.org> +Cc: linux-usb@vger.kernel.org +From: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +Subject: USB: adutux: remove custom debug macro + +Don't use a custom debug macro for just one driver, instead rely on the +in-kernel dynamic debugging logic, which can handle this much better. + +Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> + +--- + drivers/usb/misc/adutux.c | 97 +++++++++++++++++++++++++++------------------- + 1 file changed, 58 insertions(+), 39 deletions(-) + +--- a/drivers/usb/misc/adutux.c ++++ b/drivers/usb/misc/adutux.c +@@ -147,10 +147,8 @@ static void adu_abort_transfers(struct a + { + unsigned long flags; + +- if (dev->udev == NULL) { +- dbg(1, " %s : udev is null", __func__); ++ if (dev->udev == NULL) + return; +- } + + /* shutdown transfer */ + +@@ -195,8 +193,9 @@ static void adu_interrupt_in_callback(st + if (status != 0) { + if ((status != -ENOENT) && (status != -ECONNRESET) && + (status != -ESHUTDOWN)) { +- dbg(1, " %s : nonzero status received: %d", +- __func__, status); ++ dev_dbg(&dev->udev->dev, ++ "%s : nonzero status received: %d\n", ++ __func__, status); + } + goto exit; + } +@@ -210,10 +209,11 @@ static void adu_interrupt_in_callback(st + dev->interrupt_in_buffer, urb->actual_length); + + dev->read_buffer_length += urb->actual_length; +- dbg(2, " %s reading %d ", __func__, +- urb->actual_length); ++ dev_dbg(&dev->udev->dev,"%s reading %d\n", __func__, ++ urb->actual_length); + } else { +- dbg(1, " %s : read_buffer overflow", __func__); ++ dev_dbg(&dev->udev->dev,"%s : read_buffer overflow\n", ++ __func__); + } + } + +@@ -236,8 +236,9 @@ static void adu_interrupt_out_callback(s + if (status != 0) { + if ((status != -ENOENT) && + (status != -ECONNRESET)) { +- dbg(1, " %s :nonzero status received: %d", +- __func__, status); ++ dev_dbg(&dev->udev->dev, ++ "%s :nonzero status received: %d\n", __func__, ++ status); + } + goto exit; + } +@@ -262,10 +263,8 @@ static int adu_open(struct inode *inode, + subminor = iminor(inode); + + retval = mutex_lock_interruptible(&adutux_mutex); +- if (retval) { +- dbg(2, "%s : mutex lock failed", __func__); ++ if (retval) + goto exit_no_lock; +- } + + interface = usb_find_interface(&adu_driver, subminor); + if (!interface) { +@@ -288,7 +287,8 @@ static int adu_open(struct inode *inode, + } + + ++dev->open_count; +- dbg(2, "%s : open count %d", __func__, dev->open_count); ++ dev_dbg(&dev->udev->dev, "%s: open count %d\n", __func__, ++ dev->open_count); + + /* save device in the file's private structure */ + file->private_data = dev; +@@ -325,7 +325,8 @@ static void adu_release_internal(struct + { + /* decrement our usage count for the device */ + --dev->open_count; +- dbg(2, " %s : open count %d", __func__, dev->open_count); ++ dev_dbg(&dev->udev->dev, "%s : open count %d\n", __func__, ++ dev->open_count); + if (dev->open_count <= 0) { + adu_abort_transfers(dev); + dev->open_count = 0; +@@ -338,14 +339,12 @@ static int adu_release(struct inode *ino + int retval = 0; + + if (file == NULL) { +- dbg(1, " %s : file is NULL", __func__); + retval = -ENODEV; + goto exit; + } + + dev = file->private_data; + if (dev == NULL) { +- dbg(1, " %s : object is NULL", __func__); + retval = -ENODEV; + goto exit; + } +@@ -353,7 +352,7 @@ static int adu_release(struct inode *ino + mutex_lock(&adutux_mutex); /* not interruptible */ + + if (dev->open_count <= 0) { +- dbg(1, " %s : device not opened", __func__); ++ dev_dbg(&dev->udev->dev, "%s : device not opened\n", __func__); + retval = -ENODEV; + goto unlock; + } +@@ -397,17 +396,19 @@ static ssize_t adu_read(struct file *fil + + /* verify that some data was requested */ + if (count == 0) { +- dbg(1, " %s : read request of 0 bytes", __func__); ++ dev_dbg(&dev->udev->dev, "%s : read request of 0 bytes\n", ++ __func__); + goto exit; + } + + timeout = COMMAND_TIMEOUT; +- dbg(2, " %s : about to start looping", __func__); ++ dev_dbg(&dev->udev->dev, "%s : about to start looping\n", __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", +- __func__, data_in_secondary, +- dev->interrupt_in_urb->status); ++ dev_dbg(&dev->udev->dev, ++ "%s : while, data_in_secondary=%d, status=%d\n", ++ __func__, data_in_secondary, ++ dev->interrupt_in_urb->status); + + if (data_in_secondary) { + /* drain secondary buffer */ +@@ -430,8 +431,9 @@ static ssize_t adu_read(struct file *fil + if (dev->read_buffer_length) { + /* we secure access to the primary */ + char *tmp; +- dbg(2, " %s : swap, read_buffer_length = %d", +- __func__, dev->read_buffer_length); ++ dev_dbg(&dev->udev->dev, ++ "%s : swap, read_buffer_length = %d\n", ++ __func__, dev->read_buffer_length); + tmp = dev->read_buffer_secondary; + dev->read_buffer_secondary = dev->read_buffer_primary; + dev->read_buffer_primary = tmp; +@@ -446,10 +448,14 @@ static ssize_t adu_read(struct file *fil + if (!dev->read_urb_finished) { + /* somebody is doing IO */ + spin_unlock_irqrestore(&dev->buflock, flags); +- dbg(2, " %s : submitted already", __func__); ++ dev_dbg(&dev->udev->dev, ++ "%s : submitted already\n", ++ __func__); + } else { + /* we must initiate input */ +- dbg(2, " %s : initiate input", __func__); ++ dev_dbg(&dev->udev->dev, ++ "%s : initiate input\n", ++ __func__); + dev->read_urb_finished = 0; + spin_unlock_irqrestore(&dev->buflock, flags); + +@@ -467,7 +473,9 @@ static ssize_t adu_read(struct file *fil + if (retval == -ENOMEM) { + retval = bytes_read ? bytes_read : -ENOMEM; + } +- dbg(2, " %s : submit failed", __func__); ++ dev_dbg(&dev->udev->dev, ++ "%s : submit failed\n", ++ __func__); + goto exit; + } + } +@@ -486,13 +494,16 @@ static ssize_t adu_read(struct file *fil + remove_wait_queue(&dev->read_wait, &wait); + + if (timeout <= 0) { +- dbg(2, " %s : timeout", __func__); ++ dev_dbg(&dev->udev->dev, ++ "%s : timeout\n", __func__); + retval = bytes_read ? bytes_read : -ETIMEDOUT; + goto exit; + } + + if (signal_pending(current)) { +- dbg(2, " %s : signal pending", __func__); ++ dev_dbg(&dev->udev->dev, ++ "%s : signal pending\n", ++ __func__); + retval = bytes_read ? bytes_read : -EINTR; + goto exit; + } +@@ -555,7 +566,8 @@ static ssize_t adu_write(struct file *fi + + /* verify that we actually have some data to write */ + if (count == 0) { +- dbg(1, " %s : write request of 0 bytes", __func__); ++ dev_dbg(&dev->udev->dev, "%s : write request of 0 bytes\n", ++ __func__); + goto exit; + } + +@@ -568,13 +580,15 @@ static ssize_t adu_write(struct file *fi + + mutex_unlock(&dev->mtx); + if (signal_pending(current)) { +- dbg(1, " %s : interrupted", __func__); ++ dev_dbg(&dev->udev->dev, "%s : interrupted\n", ++ __func__); + set_current_state(TASK_RUNNING); + retval = -EINTR; + goto exit_onqueue; + } + if (schedule_timeout(COMMAND_TIMEOUT) == 0) { +- dbg(1, "%s - command timed out.", __func__); ++ dev_dbg(&dev->udev->dev, ++ "%s - command timed out.\n", __func__); + retval = -ETIMEDOUT; + goto exit_onqueue; + } +@@ -585,18 +599,22 @@ static ssize_t adu_write(struct file *fi + goto exit_nolock; + } + +- dbg(4, " %s : in progress, count = %Zd", __func__, count); ++ dev_dbg(&dev->udev->dev, ++ "%s : in progress, count = %Zd\n", ++ __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", __func__, count); ++ dev_dbg(&dev->udev->dev, "%s : sending, count = %Zd\n", ++ __func__, count); + + /* write the data into interrupt_out_buffer from userspace */ + buffer_size = usb_endpoint_maxp(dev->interrupt_out_endpoint); + bytes_to_write = count > buffer_size ? buffer_size : count; +- dbg(4, " %s : buffer_size = %Zd, count = %Zd, bytes_to_write = %Zd", +- __func__, buffer_size, count, bytes_to_write); ++ dev_dbg(&dev->udev->dev, ++ "%s : buffer_size = %Zd, count = %Zd, bytes_to_write = %Zd\n", ++ __func__, buffer_size, count, bytes_to_write); + + if (copy_from_user(dev->interrupt_out_buffer, buffer, bytes_to_write) != 0) { + retval = -EFAULT; +@@ -779,7 +797,7 @@ static int adu_probe(struct usb_interfac + dev_err(&interface->dev, "Could not retrieve serial number\n"); + goto error; + } +- dbg(2, " %s : serial_number=%s", __func__, dev->serial_number); ++ dev_dbg(&interface->dev,"serial_number=%s", dev->serial_number); + + /* we can register the device now, as it is ready */ + usb_set_intfdata(interface, dev); +@@ -829,7 +847,8 @@ static void adu_disconnect(struct usb_in + usb_set_intfdata(interface, NULL); + + /* if the device is not opened, then we clean up right now */ +- dbg(2, " %s : open count %d", __func__, dev->open_count); ++ dev_dbg(&dev->udev->dev, "%s : open count %d\n", ++ __func__, dev->open_count); + if (!dev->open_count) + adu_delete(dev); + diff --git a/applied/usb-adutux-remove-direct-calls-to-printk.patch b/applied/usb-adutux-remove-direct-calls-to-printk.patch new file mode 100644 index 00000000000000..56463b6254d5cf --- /dev/null +++ b/applied/usb-adutux-remove-direct-calls-to-printk.patch @@ -0,0 +1,56 @@ +From foo@baz Wed Jun 26 16:23:03 PDT 2013 +Date: Wed, 26 Jun 2013 16:23:03 -0700 +To: Greg KH <gregkh@linuxfoundation.org> +Cc: linux-usb@vger.kernel.org +From: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +Subject: USB: adutux: remove direct calls to printk() + +Use the pr_* calls instead, which are much more descriptive. + +Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +--- + drivers/usb/misc/adutux.c | 12 ++++++------ + 1 file changed, 6 insertions(+), 6 deletions(-) + +--- a/drivers/usb/misc/adutux.c ++++ b/drivers/usb/misc/adutux.c +@@ -18,6 +18,8 @@ + * + */ + ++#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt ++ + #include <linux/kernel.h> + #include <linux/errno.h> + #include <linux/init.h> +@@ -236,8 +238,8 @@ static int adu_open(struct inode *inode, + + interface = usb_find_interface(&adu_driver, subminor); + if (!interface) { +- printk(KERN_ERR "adutux: %s - error, can't find device for " +- "minor %d\n", __func__, subminor); ++ pr_err("%s - error, can't find device for minor %d\n", ++ __func__, subminor); + retval = -ENODEV; + goto exit_no_device; + } +@@ -357,8 +359,7 @@ static ssize_t adu_read(struct file *fil + /* verify that the device wasn't unplugged */ + if (dev->udev == NULL) { + retval = -ENODEV; +- printk(KERN_ERR "adutux: No device or device unplugged %d\n", +- retval); ++ pr_err("No device or device unplugged %d\n", retval); + goto exit; + } + +@@ -527,8 +528,7 @@ static ssize_t adu_write(struct file *fi + /* verify that the device wasn't unplugged */ + if (dev->udev == NULL) { + retval = -ENODEV; +- printk(KERN_ERR "adutux: No device or device unplugged %d\n", +- retval); ++ pr_err("No device or device unplugged %d\n", retval); + goto exit; + } + diff --git a/applied/usb-adutux-remove-unneeded-tracing-macros.patch b/applied/usb-adutux-remove-unneeded-tracing-macros.patch new file mode 100644 index 00000000000000..8b26214ac16e42 --- /dev/null +++ b/applied/usb-adutux-remove-unneeded-tracing-macros.patch @@ -0,0 +1,211 @@ +From foo@baz Wed Jun 26 16:21:19 PDT 2013 +Date: Wed, 26 Jun 2013 16:21:19 -0700 +To: Greg KH <gregkh@linuxfoundation.org> +Cc: linux-usb@vger.kernel.org +From: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +Subject: USB: adutux: remove unneeded tracing macros + +Remove the unneeded tracing macros in this driver. The kernel has a +built-in trace function that can be used if this is really still needed. + +Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> + +--- + drivers/usb/misc/adutux.c | 41 +---------------------------------------- + 1 file changed, 1 insertion(+), 40 deletions(-) + +--- a/drivers/usb/misc/adutux.c ++++ b/drivers/usb/misc/adutux.c +@@ -147,11 +147,9 @@ static void adu_abort_transfers(struct a + { + unsigned long flags; + +- dbg(2, " %s : enter", __func__); +- + if (dev->udev == NULL) { + dbg(1, " %s : udev is null", __func__); +- goto exit; ++ return; + } + + /* shutdown transfer */ +@@ -170,15 +168,10 @@ static void adu_abort_transfers(struct a + usb_kill_urb(dev->interrupt_out_urb); + } else + spin_unlock_irqrestore(&dev->buflock, flags); +- +-exit: +- dbg(2, " %s : leave", __func__); + } + + static void adu_delete(struct adu_device *dev) + { +- dbg(2, "%s enter", __func__); +- + /* free data structures */ + usb_free_urb(dev->interrupt_in_urb); + usb_free_urb(dev->interrupt_out_urb); +@@ -187,8 +180,6 @@ static void adu_delete(struct adu_device + kfree(dev->interrupt_in_buffer); + kfree(dev->interrupt_out_buffer); + kfree(dev); +- +- dbg(2, "%s : leave", __func__); + } + + static void adu_interrupt_in_callback(struct urb *urb) +@@ -196,7 +187,6 @@ static void adu_interrupt_in_callback(st + struct adu_device *dev = urb->context; + int status = urb->status; + +- dbg(4, " %s : enter, status %d", __func__, status); + adu_debug_data(5, __func__, urb->actual_length, + urb->transfer_buffer); + +@@ -234,7 +224,6 @@ exit: + wake_up_interruptible(&dev->read_wait); + adu_debug_data(5, __func__, urb->actual_length, + urb->transfer_buffer); +- dbg(4, " %s : leave, status %d", __func__, status); + } + + static void adu_interrupt_out_callback(struct urb *urb) +@@ -242,7 +231,6 @@ static void adu_interrupt_out_callback(s + struct adu_device *dev = urb->context; + int status = urb->status; + +- dbg(4, " %s : enter, status %d", __func__, status); + adu_debug_data(5, __func__, urb->actual_length, urb->transfer_buffer); + + if (status != 0) { +@@ -262,7 +250,6 @@ exit: + + adu_debug_data(5, __func__, urb->actual_length, + urb->transfer_buffer); +- dbg(4, " %s : leave, status %d", __func__, status); + } + + static int adu_open(struct inode *inode, struct file *file) +@@ -272,8 +259,6 @@ static int adu_open(struct inode *inode, + int subminor; + int retval; + +- dbg(2, "%s : enter", __func__); +- + subminor = iminor(inode); + + retval = mutex_lock_interruptible(&adutux_mutex); +@@ -333,14 +318,11 @@ static int adu_open(struct inode *inode, + exit_no_device: + mutex_unlock(&adutux_mutex); + exit_no_lock: +- dbg(2, "%s : leave, return value %d ", __func__, retval); + return retval; + } + + static void adu_release_internal(struct adu_device *dev) + { +- dbg(2, " %s : enter", __func__); +- + /* decrement our usage count for the device */ + --dev->open_count; + dbg(2, " %s : open count %d", __func__, dev->open_count); +@@ -348,8 +330,6 @@ static void adu_release_internal(struct + adu_abort_transfers(dev); + dev->open_count = 0; + } +- +- dbg(2, " %s : leave", __func__); + } + + static int adu_release(struct inode *inode, struct file *file) +@@ -357,8 +337,6 @@ static int adu_release(struct inode *ino + struct adu_device *dev; + int retval = 0; + +- dbg(2, " %s : enter", __func__); +- + if (file == NULL) { + dbg(1, " %s : file is NULL", __func__); + retval = -ENODEV; +@@ -389,7 +367,6 @@ static int adu_release(struct inode *ino + unlock: + mutex_unlock(&adutux_mutex); + exit: +- dbg(2, " %s : leave, return value %d", __func__, retval); + return retval; + } + +@@ -406,11 +383,7 @@ static ssize_t adu_read(struct file *fil + unsigned long flags; + DECLARE_WAITQUEUE(wait, current); + +- dbg(2, " %s : enter, count = %Zd, file=%p", __func__, count, file); +- + dev = file->private_data; +- dbg(2, " %s : dev=%p", __func__, dev); +- + if (mutex_lock_interruptible(&dev->mtx)) + return -ERESTARTSYS; + +@@ -552,7 +525,6 @@ exit: + /* unlock the device */ + mutex_unlock(&dev->mtx); + +- dbg(2, " %s : leave, return value %d", __func__, retval); + return retval; + } + +@@ -567,8 +539,6 @@ static ssize_t adu_write(struct file *fi + unsigned long flags; + int retval; + +- dbg(2, " %s : enter, count = %Zd", __func__, count); +- + dev = file->private_data; + + retval = mutex_lock_interruptible(&dev->mtx); +@@ -665,7 +635,6 @@ static ssize_t adu_write(struct file *fi + exit: + mutex_unlock(&dev->mtx); + exit_nolock: +- dbg(2, " %s : leave, return value %d", __func__, retval); + return retval; + + exit_onqueue: +@@ -711,8 +680,6 @@ static int adu_probe(struct usb_interfac + int out_end_size; + int i; + +- dbg(2, " %s : enter", __func__); +- + if (udev == NULL) { + dev_err(&interface->dev, "udev is NULL.\n"); + goto exit; +@@ -833,8 +800,6 @@ static int adu_probe(struct usb_interfac + udev->descriptor.idProduct, dev->serial_number, + (dev->minor - ADU_MINOR_BASE)); + exit: +- dbg(2, " %s : leave, return value %p (dev)", __func__, dev); +- + return retval; + + error: +@@ -852,8 +817,6 @@ static void adu_disconnect(struct usb_in + struct adu_device *dev; + int minor; + +- dbg(2, " %s : enter", __func__); +- + dev = usb_get_intfdata(interface); + + mutex_lock(&dev->mtx); /* not interruptible */ +@@ -874,8 +837,6 @@ static void adu_disconnect(struct usb_in + + dev_info(&interface->dev, "ADU device adutux%d now disconnected\n", + (minor - ADU_MINOR_BASE)); +- +- dbg(2, " %s : leave", __func__); + } + + /* usb specific object needed to register this driver with the usb subsystem */ diff --git a/applied/usb-gadget-fix-up-comment.patch b/applied/usb-gadget-fix-up-comment.patch new file mode 100644 index 00000000000000..c5d42c0e7362de --- /dev/null +++ b/applied/usb-gadget-fix-up-comment.patch @@ -0,0 +1,27 @@ +From foo@baz Fri Jun 28 11:11:19 PDT 2013 +Date: Fri, 28 Jun 2013 11:11:19 -0700 +To: Greg KH <gregkh@linuxfoundation.org> +Cc: Felipe Balbi <balbi@ti.com> +From: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +Subject: USB: gadget: fix up comment + +This endif is for CONFIG_USB_GADGET_DEBUG_FILES, not CONFIG_USB_DEBUG, +so document it properly. + +Cc: Felipe Balbi <balbi@ti.com> +Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +--- + drivers/usb/gadget/storage_common.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +--- a/drivers/usb/gadget/storage_common.c ++++ b/drivers/usb/gadget/storage_common.c +@@ -172,7 +172,7 @@ MODULE_PARM_DESC(num_buffers, "Number of + */ + #define fsg_num_buffers CONFIG_USB_GADGET_STORAGE_NUM_BUFFERS + +-#endif /* CONFIG_USB_DEBUG */ ++#endif /* CONFIG_USB_GADGET_DEBUG_FILES */ + + /* check if fsg_num_buffers is within a valid range */ + static inline int fsg_num_buffers_validate(void) diff --git a/applied/usb-isp116x-remove-dependency-on-config_usb_debug.patch b/applied/usb-isp116x-remove-dependency-on-config_usb_debug.patch new file mode 100644 index 00000000000000..6877cbfe4253d1 --- /dev/null +++ b/applied/usb-isp116x-remove-dependency-on-config_usb_debug.patch @@ -0,0 +1,54 @@ +From foo@baz Fri Jun 28 11:19:44 PDT 2013 +Date: Fri, 28 Jun 2013 11:19:44 -0700 +To: Greg KH <gregkh@linuxfoundation.org> +Cc: Olav Kongas <ok@artecdesign.ee> +From: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +Subject: USB: isp116x: remove dependency on CONFIG_USB_DEBUG + +Move all debugging messages in the driver to use the dynamic debug +subsystem, and not rely on CONFIG_USB_DEBUG to turn them on or off. + +This lets debugging be enabled without having to rebuild the driver, an +important thing for users that can not do it. + +It also removes the pointless IRQ_TEST() macro, as that was totally +useless and obviously never used. + +Cc: Olav Kongas <ok@artecdesign.ee> +Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> + +--- + drivers/usb/host/isp116x.h | 13 +------------ + 1 file changed, 1 insertion(+), 12 deletions(-) + +--- a/drivers/usb/host/isp116x.h ++++ b/drivers/usb/host/isp116x.h +@@ -325,11 +325,7 @@ struct isp116x_ep { + + /*-------------------------------------------------------------------------*/ + +-#ifdef DEBUG +-#define DBG(stuff...) printk(KERN_DEBUG "116x: " stuff) +-#else +-#define DBG(stuff...) do{}while(0) +-#endif ++#define DBG(stuff...) pr_debug("116x: " stuff) + + #ifdef VERBOSE + # define VDBG DBG +@@ -358,15 +354,8 @@ struct isp116x_ep { + #define isp116x_check_platform_delay(h) 0 + #endif + +-#if defined(DEBUG) +-#define IRQ_TEST() BUG_ON(!irqs_disabled()) +-#else +-#define IRQ_TEST() do{}while(0) +-#endif +- + static inline void isp116x_write_addr(struct isp116x *isp116x, unsigned reg) + { +- IRQ_TEST(); + writew(reg & 0xff, isp116x->addr_reg); + isp116x_delay(isp116x, 300); + } diff --git a/applied/usb-isp1362-move-debug-files-from-proc-to-debugfs.patch b/applied/usb-isp1362-move-debug-files-from-proc-to-debugfs.patch new file mode 100644 index 00000000000000..57cbeffbff4461 --- /dev/null +++ b/applied/usb-isp1362-move-debug-files-from-proc-to-debugfs.patch @@ -0,0 +1,127 @@ +From foo@baz Tue Jul 2 12:17:06 PDT 2013 +Date: Tue, 02 Jul 2013 12:17:06 -0700 +To: Greg KH <gregkh@linuxfoundation.org> +From: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +Subject: USB: isp1362: move debug files from proc to debugfs + +Drivers should not be putting debug files in /proc/ that is what debugfs +is for, so move the isp1362 driver's debug file to debugfs. + +Cc: Felipe Balbi <balbi@ti.com> +Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> + +--- + drivers/usb/host/isp1362-hcd.c | 45 ++++++++++------------------------------- + drivers/usb/host/isp1362.h | 2 - + 2 files changed, 12 insertions(+), 35 deletions(-) + +--- a/drivers/usb/host/isp1362-hcd.c ++++ b/drivers/usb/host/isp1362-hcd.c +@@ -78,6 +78,8 @@ + #include <linux/io.h> + #include <linux/bitmap.h> + #include <linux/prefetch.h> ++#include <linux/debugfs.h> ++#include <linux/seq_file.h> + + #include <asm/irq.h> + #include <asm/byteorder.h> +@@ -88,7 +90,6 @@ static int dbg_level; + module_param(dbg_level, int, 0644); + #else + module_param(dbg_level, int, 0); +-#define STUB_DEBUG_FILE + #endif + + #include "../core/usb.h" +@@ -1907,20 +1908,6 @@ static int isp1362_bus_resume(struct usb + + /*-------------------------------------------------------------------------*/ + +-#ifdef STUB_DEBUG_FILE +- +-static inline void create_debug_file(struct isp1362_hcd *isp1362_hcd) +-{ +-} +-static inline void remove_debug_file(struct isp1362_hcd *isp1362_hcd) +-{ +-} +- +-#else +- +-#include <linux/proc_fs.h> +-#include <linux/seq_file.h> +- + static void dump_irq(struct seq_file *s, char *label, u16 mask) + { + seq_printf(s, "%-15s %04x%s%s%s%s%s%s\n", label, mask, +@@ -2063,7 +2050,7 @@ static void dump_regs(struct seq_file *s + isp1362_read_reg16(isp1362_hcd, HCATLDTCTO)); + } + +-static int proc_isp1362_show(struct seq_file *s, void *unused) ++static int isp1362_show(struct seq_file *s, void *unused) + { + struct isp1362_hcd *isp1362_hcd = s->private; + struct isp1362_ep *ep; +@@ -2167,41 +2154,31 @@ static int proc_isp1362_show(struct seq_ + return 0; + } + +-static int proc_isp1362_open(struct inode *inode, struct file *file) ++static int isp1362_open(struct inode *inode, struct file *file) + { +- return single_open(file, proc_isp1362_show, PDE_DATA(inode)); ++ return single_open(file, isp1362_show, inode); + } + +-static const struct file_operations proc_ops = { +- .open = proc_isp1362_open, ++static const struct file_operations debug_ops = { ++ .open = isp1362_open, + .read = seq_read, + .llseek = seq_lseek, + .release = single_release, + }; + + /* expect just one isp1362_hcd per system */ +-static const char proc_filename[] = "driver/isp1362"; +- + static void create_debug_file(struct isp1362_hcd *isp1362_hcd) + { +- struct proc_dir_entry *pde; +- +- pde = proc_create_data(proc_filename, 0, NULL, &proc_ops, isp1362_hcd); +- if (pde == NULL) { +- pr_warning("%s: Failed to create debug file '%s'\n", __func__, proc_filename); +- return; +- } +- isp1362_hcd->pde = pde; ++ isp1362_hcd->debug_file = debugfs_create_file("isp1362", S_IRUGO, ++ usb_debug_root, ++ isp1362_hcd, &debug_ops); + } + + static void remove_debug_file(struct isp1362_hcd *isp1362_hcd) + { +- if (isp1362_hcd->pde) +- remove_proc_entry(proc_filename, NULL); ++ debugfs_remove(isp1362_hcd->debug_file); + } + +-#endif +- + /*-------------------------------------------------------------------------*/ + + static void __isp1362_sw_reset(struct isp1362_hcd *isp1362_hcd) +--- a/drivers/usb/host/isp1362.h ++++ b/drivers/usb/host/isp1362.h +@@ -480,7 +480,7 @@ struct isp1362_hcd { + + struct isp1362_platform_data *board; + +- struct proc_dir_entry *pde; ++ struct dentry *debug_file; + unsigned long stat1, stat2, stat4, stat8, stat16; + + /* HC registers */ diff --git a/applied/usb-isp1362-remove-_dbg-usage.patch b/applied/usb-isp1362-remove-_dbg-usage.patch new file mode 100644 index 00000000000000..ba87fd83f214fd --- /dev/null +++ b/applied/usb-isp1362-remove-_dbg-usage.patch @@ -0,0 +1,142 @@ +From foo@baz Fri Jun 28 11:14:57 PDT 2013 +Date: Fri, 28 Jun 2013 11:14:57 -0700 +To: Greg KH <gregkh@linuxfoundation.org> +Cc: Felipe Balbi <balbi@ti.com> +From: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +Subject: USB: isp1362: remove _DBG() usage + +If you want a debug call, just make it, so move to using the +already-there DBG() call. No need to make things more complex than they +really need to be. + +Cc: Felipe Balbi <balbi@ti.com> +Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +--- + drivers/usb/host/isp1362-hcd.c | 30 +++++++++++++++--------------- + drivers/usb/host/isp1362.h | 6 ------ + 2 files changed, 15 insertions(+), 21 deletions(-) + +--- a/drivers/usb/host/isp1362-hcd.c ++++ b/drivers/usb/host/isp1362-hcd.c +@@ -1573,12 +1573,12 @@ static int isp1362_hub_control(struct us + DBG(0, "ClearHubFeature: "); + switch (wValue) { + case C_HUB_OVER_CURRENT: +- _DBG(0, "C_HUB_OVER_CURRENT\n"); ++ DBG(0, "C_HUB_OVER_CURRENT\n"); + spin_lock_irqsave(&isp1362_hcd->lock, flags); + isp1362_write_reg32(isp1362_hcd, HCRHSTATUS, RH_HS_OCIC); + spin_unlock_irqrestore(&isp1362_hcd->lock, flags); + case C_HUB_LOCAL_POWER: +- _DBG(0, "C_HUB_LOCAL_POWER\n"); ++ DBG(0, "C_HUB_LOCAL_POWER\n"); + break; + default: + goto error; +@@ -1589,7 +1589,7 @@ static int isp1362_hub_control(struct us + switch (wValue) { + case C_HUB_OVER_CURRENT: + case C_HUB_LOCAL_POWER: +- _DBG(0, "C_HUB_OVER_CURRENT or C_HUB_LOCAL_POWER\n"); ++ DBG(0, "C_HUB_OVER_CURRENT or C_HUB_LOCAL_POWER\n"); + break; + default: + goto error; +@@ -1620,36 +1620,36 @@ static int isp1362_hub_control(struct us + + switch (wValue) { + case USB_PORT_FEAT_ENABLE: +- _DBG(0, "USB_PORT_FEAT_ENABLE\n"); ++ DBG(0, "USB_PORT_FEAT_ENABLE\n"); + tmp = RH_PS_CCS; + break; + case USB_PORT_FEAT_C_ENABLE: +- _DBG(0, "USB_PORT_FEAT_C_ENABLE\n"); ++ DBG(0, "USB_PORT_FEAT_C_ENABLE\n"); + tmp = RH_PS_PESC; + break; + case USB_PORT_FEAT_SUSPEND: +- _DBG(0, "USB_PORT_FEAT_SUSPEND\n"); ++ DBG(0, "USB_PORT_FEAT_SUSPEND\n"); + tmp = RH_PS_POCI; + break; + case USB_PORT_FEAT_C_SUSPEND: +- _DBG(0, "USB_PORT_FEAT_C_SUSPEND\n"); ++ DBG(0, "USB_PORT_FEAT_C_SUSPEND\n"); + tmp = RH_PS_PSSC; + break; + case USB_PORT_FEAT_POWER: +- _DBG(0, "USB_PORT_FEAT_POWER\n"); ++ DBG(0, "USB_PORT_FEAT_POWER\n"); + tmp = RH_PS_LSDA; + + break; + case USB_PORT_FEAT_C_CONNECTION: +- _DBG(0, "USB_PORT_FEAT_C_CONNECTION\n"); ++ DBG(0, "USB_PORT_FEAT_C_CONNECTION\n"); + tmp = RH_PS_CSC; + break; + case USB_PORT_FEAT_C_OVER_CURRENT: +- _DBG(0, "USB_PORT_FEAT_C_OVER_CURRENT\n"); ++ DBG(0, "USB_PORT_FEAT_C_OVER_CURRENT\n"); + tmp = RH_PS_OCIC; + break; + case USB_PORT_FEAT_C_RESET: +- _DBG(0, "USB_PORT_FEAT_C_RESET\n"); ++ DBG(0, "USB_PORT_FEAT_C_RESET\n"); + tmp = RH_PS_PRSC; + break; + default: +@@ -1669,7 +1669,7 @@ static int isp1362_hub_control(struct us + wIndex--; + switch (wValue) { + case USB_PORT_FEAT_SUSPEND: +- _DBG(0, "USB_PORT_FEAT_SUSPEND\n"); ++ DBG(0, "USB_PORT_FEAT_SUSPEND\n"); + spin_lock_irqsave(&isp1362_hcd->lock, flags); + isp1362_write_reg32(isp1362_hcd, HCRHPORT1 + wIndex, RH_PS_PSS); + isp1362_hcd->rhport[wIndex] = +@@ -1677,7 +1677,7 @@ static int isp1362_hub_control(struct us + spin_unlock_irqrestore(&isp1362_hcd->lock, flags); + break; + case USB_PORT_FEAT_POWER: +- _DBG(0, "USB_PORT_FEAT_POWER\n"); ++ DBG(0, "USB_PORT_FEAT_POWER\n"); + spin_lock_irqsave(&isp1362_hcd->lock, flags); + isp1362_write_reg32(isp1362_hcd, HCRHPORT1 + wIndex, RH_PS_PPS); + isp1362_hcd->rhport[wIndex] = +@@ -1685,7 +1685,7 @@ static int isp1362_hub_control(struct us + spin_unlock_irqrestore(&isp1362_hcd->lock, flags); + break; + case USB_PORT_FEAT_RESET: +- _DBG(0, "USB_PORT_FEAT_RESET\n"); ++ DBG(0, "USB_PORT_FEAT_RESET\n"); + spin_lock_irqsave(&isp1362_hcd->lock, flags); + + t1 = jiffies + msecs_to_jiffies(USB_RESET_WIDTH); +@@ -1719,7 +1719,7 @@ static int isp1362_hub_control(struct us + default: + error: + /* "protocol stall" on error */ +- _DBG(0, "PROTOCOL STALL\n"); ++ DBG(0, "PROTOCOL STALL\n"); + retval = -EPIPE; + } + +--- a/drivers/usb/host/isp1362.h ++++ b/drivers/usb/host/isp1362.h +@@ -588,14 +588,8 @@ static inline struct usb_hcd *isp1362_hc + if (dbg_level > level) \ + pr_debug(fmt); \ + } while (0) +-#define _DBG(level, fmt...) \ +- do { \ +- if (dbg_level > level) \ +- printk(fmt); \ +- } while (0) + #else + #define DBG(fmt...) do {} while (0) +-#define _DBG DBG + #endif + + #ifdef VERBOSE diff --git a/applied/usb-isp1362-remove-config_usb_debug-dependency.patch b/applied/usb-isp1362-remove-config_usb_debug-dependency.patch new file mode 100644 index 00000000000000..2b3733b45382b2 --- /dev/null +++ b/applied/usb-isp1362-remove-config_usb_debug-dependency.patch @@ -0,0 +1,98 @@ +From foo@baz Fri Jun 28 11:16:30 PDT 2013 +Date: Fri, 28 Jun 2013 11:16:30 -0700 +To: Greg KH <gregkh@linuxfoundation.org> +Cc: Felipe Balbi <balbi@ti.com> +From: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +Subject: USB: isp1362: remove CONFIG_USB_DEBUG dependency + +Now that the debugging macros are cleaned up, just rely on the dynamic +debug code in the kernel to do the debug messages for the driver. + +This lets debugging be enabled without having to rebuild the driver, an +important thing for users that can not do it. + +Cc: Felipe Balbi <balbi@ti.com> +Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +--- + drivers/usb/host/isp1362-hcd.c | 6 +----- + drivers/usb/host/isp1362.h | 16 ++++------------ + 2 files changed, 5 insertions(+), 17 deletions(-) + +--- a/drivers/usb/host/isp1362-hcd.c ++++ b/drivers/usb/host/isp1362-hcd.c +@@ -37,11 +37,7 @@ + * recovery time (MSCx = 0x7f8c) with a memory clock of 99.53 MHz. + */ + +-#ifdef CONFIG_USB_DEBUG +-# define ISP1362_DEBUG +-#else +-# undef ISP1362_DEBUG +-#endif ++#undef ISP1362_DEBUG + + /* + * The PXA255 UDC apparently doesn't handle GET_STATUS, GET_CONFIG and +--- a/drivers/usb/host/isp1362.h ++++ b/drivers/usb/host/isp1362.h +@@ -76,14 +76,14 @@ static inline void delayed_insw(unsigned + + #define ISP1362_REG_WRITE_OFFSET 0x80 + +-#ifdef ISP1362_DEBUG +-typedef const unsigned int isp1362_reg_t; +- + #define REG_WIDTH_16 0x000 + #define REG_WIDTH_32 0x100 + #define REG_WIDTH_MASK 0x100 + #define REG_NO_MASK 0x0ff + ++#ifdef ISP1362_DEBUG ++typedef const unsigned int isp1362_reg_t; ++ + #define REG_ACCESS_R 0x200 + #define REG_ACCESS_W 0x400 + #define REG_ACCESS_RW 0x600 +@@ -582,15 +582,11 @@ static inline struct usb_hcd *isp1362_hc + * ISP1362 HW Interface + */ + +-#ifdef ISP1362_DEBUG + #define DBG(level, fmt...) \ + do { \ + if (dbg_level > level) \ + pr_debug(fmt); \ + } while (0) +-#else +-#define DBG(fmt...) do {} while (0) +-#endif + + #ifdef VERBOSE + # define VDBG(fmt...) DBG(3, fmt) +@@ -833,7 +829,6 @@ static void isp1362_write_fifo(struct is + isp1362_write_reg32(d, r, __v & ~m); \ + } + +-#ifdef ISP1362_DEBUG + #define isp1362_show_reg(d, r) { \ + if ((ISP1362_REG_##r & REG_WIDTH_MASK) == REG_WIDTH_32) \ + DBG(0, "%-12s[%02x]: %08x\n", #r, \ +@@ -842,9 +837,6 @@ static void isp1362_write_fifo(struct is + DBG(0, "%-12s[%02x]: %04x\n", #r, \ + ISP1362_REG_NO(ISP1362_REG_##r), isp1362_read_reg16(d, r)); \ + } +-#else +-#define isp1362_show_reg(d, r) do {} while (0) +-#endif + + static void __attribute__((__unused__)) isp1362_show_regs(struct isp1362_hcd *isp1362_hcd) + { +@@ -967,7 +959,7 @@ static void __attribute__((unused)) dump + } + } + +-#if defined(ISP1362_DEBUG) && defined(PTD_TRACE) ++#if defined(PTD_TRACE) + + static void dump_ptd(struct ptd *ptd) + { diff --git a/applied/usb-isp1362-remove-unused-_bug_on-calls.patch b/applied/usb-isp1362-remove-unused-_bug_on-calls.patch new file mode 100644 index 00000000000000..c1d3e7fc8277d3 --- /dev/null +++ b/applied/usb-isp1362-remove-unused-_bug_on-calls.patch @@ -0,0 +1,137 @@ +From foo@baz Fri Jun 28 11:12:12 PDT 2013 +Date: Fri, 28 Jun 2013 11:12:12 -0700 +To: Greg KH <gregkh@linuxfoundation.org> +Cc: Felipe Balbi <balbi@ti.com> +From: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +Subject: USB: isp1362: remove unused _BUG_ON() calls + +We shouldn't ever panic in a driver, and these calls were never being +used, so just delete them, as obviously the driver is working properly +now (right?) + +Cc: Felipe Balbi <balbi@ti.com> +Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> + +--- + drivers/usb/host/isp1362-hcd.c | 2 -- + drivers/usb/host/isp1362.h | 20 -------------------- + 2 files changed, 22 deletions(-) + +--- a/drivers/usb/host/isp1362-hcd.c ++++ b/drivers/usb/host/isp1362-hcd.c +@@ -350,8 +350,6 @@ static void isp1362_write_ptd(struct isp + struct ptd *ptd = &ep->ptd; + int len = PTD_GET_DIR(ptd) == PTD_DIR_IN ? 0 : ep->length; + +- _BUG_ON(ep->ptd_offset < 0); +- + prefetch(ptd); + isp1362_write_buffer(isp1362_hcd, ptd, ep->ptd_offset, PTD_HEADER_SIZE); + if (len) +--- a/drivers/usb/host/isp1362.h ++++ b/drivers/usb/host/isp1362.h +@@ -91,7 +91,6 @@ typedef const unsigned int isp1362_reg_t + + #define ISP1362_REG_NO(r) ((r) & REG_NO_MASK) + +-#define _BUG_ON(x) BUG_ON(x) + #define _WARN_ON(x) WARN_ON(x) + + #define ISP1362_REG(name, addr, width, rw) \ +@@ -102,7 +101,6 @@ static isp1362_reg_t ISP1362_REG_##name + #else + typedef const unsigned char isp1362_reg_t; + #define ISP1362_REG_NO(r) (r) +-#define _BUG_ON(x) do {} while (0) + #define _WARN_ON(x) do {} while (0) + + #define ISP1362_REG(name, addr, width, rw) \ +@@ -645,9 +643,7 @@ static inline struct usb_hcd *isp1362_hc + */ + static void isp1362_write_addr(struct isp1362_hcd *isp1362_hcd, isp1362_reg_t reg) + { +- /*_BUG_ON((reg & ISP1362_REG_WRITE_OFFSET) && !(reg & REG_ACCESS_W));*/ + REG_ACCESS_TEST(reg); +- _BUG_ON(!irqs_disabled()); + DUMMY_DELAY_ACCESS; + writew(ISP1362_REG_NO(reg), isp1362_hcd->addr_reg); + DUMMY_DELAY_ACCESS; +@@ -656,7 +652,6 @@ static void isp1362_write_addr(struct is + + static void isp1362_write_data16(struct isp1362_hcd *isp1362_hcd, u16 val) + { +- _BUG_ON(!irqs_disabled()); + DUMMY_DELAY_ACCESS; + writew(val, isp1362_hcd->data_reg); + } +@@ -665,7 +660,6 @@ static u16 isp1362_read_data16(struct is + { + u16 val; + +- _BUG_ON(!irqs_disabled()); + DUMMY_DELAY_ACCESS; + val = readw(isp1362_hcd->data_reg); + +@@ -674,7 +668,6 @@ static u16 isp1362_read_data16(struct is + + static void isp1362_write_data32(struct isp1362_hcd *isp1362_hcd, u32 val) + { +- _BUG_ON(!irqs_disabled()); + #if USE_32BIT + DUMMY_DELAY_ACCESS; + writel(val, isp1362_hcd->data_reg); +@@ -690,7 +683,6 @@ static u32 isp1362_read_data32(struct is + { + u32 val; + +- _BUG_ON(!irqs_disabled()); + #if USE_32BIT + DUMMY_DELAY_ACCESS; + val = readl(isp1362_hcd->data_reg); +@@ -713,8 +705,6 @@ static void isp1362_read_fifo(struct isp + if (!len) + return; + +- _BUG_ON(!irqs_disabled()); +- + RDBG("%s: Reading %d byte from fifo to mem @ %p\n", __func__, len, buf); + #if USE_32BIT + if (len >= 4) { +@@ -760,8 +750,6 @@ static void isp1362_write_fifo(struct is + return; + } + +- _BUG_ON(!irqs_disabled()); +- + RDBG("%s: Writing %d byte to fifo from memory @%p\n", __func__, len, buf); + #if USE_32BIT + if (len >= 4) { +@@ -923,10 +911,6 @@ static void __attribute__((__unused__)) + + static void isp1362_write_diraddr(struct isp1362_hcd *isp1362_hcd, u16 offset, u16 len) + { +- _BUG_ON(offset & 1); +- _BUG_ON(offset >= ISP1362_BUF_SIZE); +- _BUG_ON(len > ISP1362_BUF_SIZE); +- _BUG_ON(offset + len > ISP1362_BUF_SIZE); + len = (len + 1) & ~1; + + isp1362_clr_mask16(isp1362_hcd, HCDMACFG, HCDMACFG_CTR_ENABLE); +@@ -936,8 +920,6 @@ static void isp1362_write_diraddr(struct + + static void isp1362_read_buffer(struct isp1362_hcd *isp1362_hcd, void *buf, u16 offset, int len) + { +- _BUG_ON(offset & 1); +- + isp1362_write_diraddr(isp1362_hcd, offset, len); + + DBG(3, "%s: Reading %d byte from buffer @%04x to memory @ %p\n", +@@ -956,8 +938,6 @@ static void isp1362_read_buffer(struct i + + static void isp1362_write_buffer(struct isp1362_hcd *isp1362_hcd, void *buf, u16 offset, int len) + { +- _BUG_ON(offset & 1); +- + isp1362_write_diraddr(isp1362_hcd, offset, len); + + DBG(3, "%s: Writing %d byte to buffer @%04x from memory @ %p\n", diff --git a/applied/usb-isp1362-remove-unused-_warn_on-calls.patch b/applied/usb-isp1362-remove-unused-_warn_on-calls.patch new file mode 100644 index 00000000000000..dc110f20767024 --- /dev/null +++ b/applied/usb-isp1362-remove-unused-_warn_on-calls.patch @@ -0,0 +1,67 @@ +From foo@baz Fri Jun 28 11:13:39 PDT 2013 +Date: Fri, 28 Jun 2013 11:13:39 -0700 +To: Greg KH <gregkh@linuxfoundation.org> +Cc: Felipe Balbi <balbi@ti.com> +From: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +Subject: USB: isp1362: remove unused _WARN_ON() calls + +Like _BUG_ON(), _WARN_ON() wasn't ever being used, so just delete it, as +obviously things are working properly now (if not, we have bigger +problems...) + +Cc: Felipe Balbi <balbi@ti.com> +Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> + +--- + drivers/usb/host/isp1362.h | 9 --------- + 1 file changed, 9 deletions(-) + +--- a/drivers/usb/host/isp1362.h ++++ b/drivers/usb/host/isp1362.h +@@ -91,8 +91,6 @@ typedef const unsigned int isp1362_reg_t + + #define ISP1362_REG_NO(r) ((r) & REG_NO_MASK) + +-#define _WARN_ON(x) WARN_ON(x) +- + #define ISP1362_REG(name, addr, width, rw) \ + static isp1362_reg_t ISP1362_REG_##name = ((addr) | (width) | (rw)) + +@@ -101,7 +99,6 @@ static isp1362_reg_t ISP1362_REG_##name + #else + typedef const unsigned char isp1362_reg_t; + #define ISP1362_REG_NO(r) (r) +-#define _WARN_ON(x) do {} while (0) + + #define ISP1362_REG(name, addr, width, rw) \ + static isp1362_reg_t ISP1362_REG_##name = addr +@@ -926,14 +923,11 @@ static void isp1362_read_buffer(struct i + __func__, len, offset, buf); + + isp1362_write_reg16(isp1362_hcd, HCuPINT, HCuPINT_EOT); +- _WARN_ON((isp1362_read_reg16(isp1362_hcd, HCuPINT) & HCuPINT_EOT)); + + isp1362_write_addr(isp1362_hcd, ISP1362_REG_HCDIRDATA); + + isp1362_read_fifo(isp1362_hcd, buf, len); +- _WARN_ON(!(isp1362_read_reg16(isp1362_hcd, HCuPINT) & HCuPINT_EOT)); + isp1362_write_reg16(isp1362_hcd, HCuPINT, HCuPINT_EOT); +- _WARN_ON((isp1362_read_reg16(isp1362_hcd, HCuPINT) & HCuPINT_EOT)); + } + + static void isp1362_write_buffer(struct isp1362_hcd *isp1362_hcd, void *buf, u16 offset, int len) +@@ -944,14 +938,11 @@ static void isp1362_write_buffer(struct + __func__, len, offset, buf); + + isp1362_write_reg16(isp1362_hcd, HCuPINT, HCuPINT_EOT); +- _WARN_ON((isp1362_read_reg16(isp1362_hcd, HCuPINT) & HCuPINT_EOT)); + + isp1362_write_addr(isp1362_hcd, ISP1362_REG_HCDIRDATA | ISP1362_REG_WRITE_OFFSET); + isp1362_write_fifo(isp1362_hcd, buf, len); + +- _WARN_ON(!(isp1362_read_reg16(isp1362_hcd, HCuPINT) & HCuPINT_EOT)); + isp1362_write_reg16(isp1362_hcd, HCuPINT, HCuPINT_EOT); +- _WARN_ON((isp1362_read_reg16(isp1362_hcd, HCuPINT) & HCuPINT_EOT)); + } + + static void __attribute__((unused)) dump_data(char *buf, int len) diff --git a/applied/usb-ldusb-remove-custom-dbg_info-macro.patch b/applied/usb-ldusb-remove-custom-dbg_info-macro.patch new file mode 100644 index 00000000000000..ebb53dde670bad --- /dev/null +++ b/applied/usb-ldusb-remove-custom-dbg_info-macro.patch @@ -0,0 +1,86 @@ +From foo@baz Wed Jun 26 16:13:27 PDT 2013 +Date: Wed, 26 Jun 2013 16:13:27 -0700 +To: Greg KH <gregkh@linuxfoundation.org> +Cc: linux-usb@vger.kernel.org +From: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +Subject: USB: ldusb: remove custom dbg_info() macro + +We want to get rid of CONFIG_USB_DEBUG, so remove the reliance of the +ldusb driver on it. Don't use the custom macro, or a special module +parameter, instead, rely on the in-kernel dynamic debugging +infrastructure, which is much easier to use, and consistant across the +whole kernel. + +Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +--- + drivers/usb/misc/ldusb.c | 31 ++++++++++--------------------- + 1 file changed, 10 insertions(+), 21 deletions(-) + +--- a/drivers/usb/misc/ldusb.c ++++ b/drivers/usb/misc/ldusb.c +@@ -129,19 +129,6 @@ MODULE_DESCRIPTION("LD USB Driver"); + MODULE_LICENSE("GPL"); + MODULE_SUPPORTED_DEVICE("LD USB Devices"); + +-#ifdef CONFIG_USB_DEBUG +- static int debug = 1; +-#else +- static int debug = 0; +-#endif +- +-/* Use our own dbg macro */ +-#define dbg_info(dev, format, arg...) do { if (debug) dev_info(dev , format , ## arg); } while (0) +- +-/* Module parameters */ +-module_param(debug, int, S_IRUGO | S_IWUSR); +-MODULE_PARM_DESC(debug, "Debug enabled or not"); +- + /* All interrupt in transfers are collected in a ring buffer to + * avoid racing conditions and get better performance of the driver. + */ +@@ -256,8 +243,9 @@ static void ld_usb_interrupt_in_callback + status == -ESHUTDOWN) { + goto exit; + } else { +- dbg_info(&dev->intf->dev, "%s: nonzero status received: %d\n", +- __func__, status); ++ dev_dbg(&dev->intf->dev, ++ "%s: nonzero status received: %d\n", __func__, ++ status); + spin_lock(&dev->rbsl); + goto resubmit; /* maybe we can recover */ + } +@@ -272,8 +260,8 @@ static void ld_usb_interrupt_in_callback + *actual_buffer = urb->actual_length; + 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", +- __func__, urb->actual_length); ++ dev_dbg(&dev->intf->dev, "%s: received %d bytes\n", ++ __func__, urb->actual_length); + } else { + dev_warn(&dev->intf->dev, + "Ring buffer overflow, %d bytes dropped\n", +@@ -310,9 +298,9 @@ static void ld_usb_interrupt_out_callbac + if (status && !(status == -ENOENT || + status == -ECONNRESET || + status == -ESHUTDOWN)) +- dbg_info(&dev->intf->dev, +- "%s - nonzero write interrupt status received: %d\n", +- __func__, status); ++ dev_dbg(&dev->intf->dev, ++ "%s - nonzero write interrupt status received: %d\n", ++ __func__, status); + + dev->interrupt_out_busy = 0; + wake_up_interruptible(&dev->write_wait); +@@ -585,7 +573,8 @@ static ssize_t ld_usb_write(struct file + 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", __func__, count, bytes_to_write); ++ dev_dbg(&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; diff --git a/applied/usb-legotower-remove-custom-debug-macro-and-module-parameter.patch b/applied/usb-legotower-remove-custom-debug-macro-and-module-parameter.patch new file mode 100644 index 00000000000000..b2ac3a9adb1445 --- /dev/null +++ b/applied/usb-legotower-remove-custom-debug-macro-and-module-parameter.patch @@ -0,0 +1,114 @@ +From foo@baz Wed Jun 26 16:17:57 PDT 2013 +Date: Wed, 26 Jun 2013 16:17:57 -0700 +To: Greg KH <gregkh@linuxfoundation.org>, Juergen Stuber <starblue@users.sourceforge.net> +Cc: linux-usb@vger.kernel.org +From: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +Subject: USB: legotower: remove custom debug macro and module parameter + +Now that we don't use the dbg() macro, remove it, and the module +parameter. Also fix up the "dump_data" function to properly use the +dynamic debug core and the correct printk options, and don't call it +twice per function, as the data doesn't change from the beginning and +the end of the call. + +Cc: Juergen Stuber <starblue@users.sourceforge.net> +Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> + + +--- + drivers/usb/misc/legousbtower.c | 43 ++++++++-------------------------------- + 1 file changed, 9 insertions(+), 34 deletions(-) + +--- a/drivers/usb/misc/legousbtower.c ++++ b/drivers/usb/misc/legousbtower.c +@@ -87,28 +87,11 @@ + #include <linux/poll.h> + + +-#ifdef CONFIG_USB_DEBUG +- static int debug = 4; +-#else +- static int debug = 0; +-#endif +- +-/* Use our own dbg macro */ +-#undef dbg +-#define dbg(lvl, format, arg...) \ +-do { \ +- if (debug >= lvl) \ +- printk(KERN_DEBUG "%s: " format "\n", __FILE__, ##arg); \ +-} while (0) +- + /* Version Information */ + #define DRIVER_VERSION "v0.96" + #define DRIVER_AUTHOR "Juergen Stuber <starblue@sourceforge.net>" + #define DRIVER_DESC "LEGO USB Tower Driver" + +-/* Module parameters */ +-module_param(debug, int, S_IRUGO | S_IWUSR); +-MODULE_PARM_DESC(debug, "Debug enabled or not"); + + /* The defaults are chosen to work with the latest versions of leJOS and NQC. + */ +@@ -298,18 +281,12 @@ static struct usb_driver tower_driver = + /** + * lego_usb_tower_debug_data + */ +-static inline void lego_usb_tower_debug_data (int level, const char *function, int size, const unsigned char *data) ++static inline void lego_usb_tower_debug_data(struct device *dev, ++ const char *function, int size, ++ const unsigned char *data) + { +- int i; +- +- if (debug < level) +- return; +- +- printk (KERN_DEBUG "%s: %s - length = %d, data = ", __FILE__, function, size); +- for (i = 0; i < size; ++i) { +- printk ("%.2x ", data[i]); +- } +- printk ("\n"); ++ dev_dbg(dev, "%s - length = %d, data = %*ph\n", ++ function, size, size, data); + } + + +@@ -744,7 +721,8 @@ static void tower_interrupt_in_callback + int status = urb->status; + int retval; + +- lego_usb_tower_debug_data(5, __func__, urb->actual_length, urb->transfer_buffer); ++ lego_usb_tower_debug_data(&dev->udev->dev, __func__, ++ urb->actual_length, urb->transfer_buffer); + + if (status) { + if (status == -ENOENT || +@@ -788,8 +766,6 @@ resubmit: + exit: + dev->interrupt_in_done = 1; + wake_up_interruptible (&dev->read_wait); +- +- lego_usb_tower_debug_data(5, __func__, urb->actual_length, urb->transfer_buffer); + } + + +@@ -801,7 +777,8 @@ static void tower_interrupt_out_callback + struct lego_usb_tower *dev = urb->context; + int status = urb->status; + +- lego_usb_tower_debug_data(5, __func__, urb->actual_length, urb->transfer_buffer); ++ lego_usb_tower_debug_data(&dev->udev->dev, __func__, ++ urb->actual_length, urb->transfer_buffer); + + /* sync/async unlink faults aren't errors */ + if (status && !(status == -ENOENT || +@@ -814,8 +791,6 @@ static void tower_interrupt_out_callback + + dev->interrupt_out_busy = 0; + wake_up_interruptible(&dev->write_wait); +- +- lego_usb_tower_debug_data(5, __func__, urb->actual_length, urb->transfer_buffer); + } + + diff --git a/applied/usb-legotower-remove-direct-calls-to-printk.patch b/applied/usb-legotower-remove-direct-calls-to-printk.patch new file mode 100644 index 00000000000000..de03d6ee712f12 --- /dev/null +++ b/applied/usb-legotower-remove-direct-calls-to-printk.patch @@ -0,0 +1,64 @@ +From foo@baz Wed Jun 26 16:19:44 PDT 2013 +Date: Wed, 26 Jun 2013 16:19:44 -0700 +To: Greg KH <gregkh@linuxfoundation.org>, Juergen Stuber <starblue@users.sourceforge.net> +Cc: linux-usb@vger.kernel.org +From: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +Subject: USB: legotower: remove direct calls to printk() + +Use the pr_* calls instead, which are much more descriptive. + +Cc: Juergen Stuber <starblue@users.sourceforge.net> +Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +--- + drivers/usb/misc/legousbtower.c | 12 +++++++----- + 1 file changed, 7 insertions(+), 5 deletions(-) + +--- a/drivers/usb/misc/legousbtower.c ++++ b/drivers/usb/misc/legousbtower.c +@@ -75,6 +75,8 @@ + * - move reset into open to clean out spurious data + */ + ++#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt ++ + #include <linux/kernel.h> + #include <linux/errno.h> + #include <linux/init.h> +@@ -325,8 +327,7 @@ static int tower_open (struct inode *ino + interface = usb_find_interface (&tower_driver, subminor); + + if (!interface) { +- printk(KERN_ERR "%s - error, can't find device for minor %d\n", +- __func__, subminor); ++ pr_err("error, can't find device for minor %d\n", subminor); + retval = -ENODEV; + goto exit; + } +@@ -563,7 +564,7 @@ static ssize_t tower_read (struct file * + /* verify that the device wasn't unplugged */ + if (dev->udev == NULL) { + retval = -ENODEV; +- printk(KERN_ERR "legousbtower: No device or device unplugged %d\n", retval); ++ pr_err("No device or device unplugged %d\n", retval); + goto unlock_exit; + } + +@@ -649,7 +650,7 @@ static ssize_t tower_write (struct file + /* verify that the device wasn't unplugged */ + if (dev->udev == NULL) { + retval = -ENODEV; +- printk(KERN_ERR "legousbtower: No device or device unplugged %d\n", retval); ++ pr_err("No device or device unplugged %d\n", retval); + goto unlock_exit; + } + +@@ -748,7 +749,8 @@ static void tower_interrupt_in_callback + dev_dbg(&dev->udev->dev, "%s: received %d bytes\n", + __func__, urb->actual_length); + } else { +- printk(KERN_WARNING "%s: read_buffer overflow, %d bytes dropped", __func__, urb->actual_length); ++ pr_warn("read_buffer overflow, %d bytes dropped\n", ++ urb->actual_length); + } + spin_unlock (&dev->read_buffer_lock); + } diff --git a/applied/usb-legotower-remove-unneeded-tracing-macros.patch b/applied/usb-legotower-remove-unneeded-tracing-macros.patch new file mode 100644 index 00000000000000..2a1566fa382755 --- /dev/null +++ b/applied/usb-legotower-remove-unneeded-tracing-macros.patch @@ -0,0 +1,217 @@ +From foo@baz Wed Jun 26 16:15:10 PDT 2013 +Date: Wed, 26 Jun 2013 16:15:10 -0700 +To: Greg KH <gregkh@linuxfoundation.org>, Juergen Stuber <starblue@users.sourceforge.net> +Cc: linux-usb@vger.kernel.org +From: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +Subject: USB: legotower: remove unneeded tracing macros + +Remove the unneeded tracing macros in this driver. The kernel has a +built-in trace function that can be used if this is really still needed. + + +Cc: Juergen Stuber <starblue@users.sourceforge.net> +Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +--- + drivers/usb/misc/legousbtower.c | 42 ---------------------------------------- + 1 file changed, 1 insertion(+), 41 deletions(-) + +--- a/drivers/usb/misc/legousbtower.c ++++ b/drivers/usb/misc/legousbtower.c +@@ -318,8 +318,6 @@ static inline void lego_usb_tower_debug_ + */ + static inline void tower_delete (struct lego_usb_tower *dev) + { +- dbg(2, "%s: enter", __func__); +- + tower_abort_transfers (dev); + + /* free data structures */ +@@ -329,8 +327,6 @@ static inline void tower_delete (struct + kfree (dev->interrupt_in_buffer); + kfree (dev->interrupt_out_buffer); + kfree (dev); +- +- dbg(2, "%s: leave", __func__); + } + + +@@ -346,8 +342,6 @@ static int tower_open (struct inode *ino + struct tower_reset_reply reset_reply; + int result; + +- dbg(2, "%s: enter", __func__); +- + nonseekable_open(inode, file); + subminor = iminor(inode); + +@@ -435,8 +429,6 @@ unlock_exit: + mutex_unlock(&dev->lock); + + exit: +- dbg(2, "%s: leave, return value %d ", __func__, retval); +- + return retval; + } + +@@ -448,8 +440,6 @@ static int tower_release (struct inode * + struct lego_usb_tower *dev; + int retval = 0; + +- dbg(2, "%s: enter", __func__); +- + dev = file->private_data; + + if (dev == NULL) { +@@ -491,7 +481,6 @@ unlock_exit: + exit: + mutex_unlock(&open_disc_mutex); + exit_nolock: +- dbg(2, "%s: leave, return value %d", __func__, retval); + return retval; + } + +@@ -502,11 +491,9 @@ exit_nolock: + */ + static void tower_abort_transfers (struct lego_usb_tower *dev) + { +- dbg(2, "%s: enter", __func__); +- + if (dev == NULL) { + dbg(1, "%s: dev is null", __func__); +- goto exit; ++ return; + } + + /* shutdown transfer */ +@@ -518,9 +505,6 @@ static void tower_abort_transfers (struc + } + if (dev->interrupt_out_busy && dev->udev) + usb_kill_urb(dev->interrupt_out_urb); +- +-exit: +- dbg(2, "%s: leave", __func__); + } + + +@@ -553,8 +537,6 @@ static unsigned int tower_poll (struct f + struct lego_usb_tower *dev; + unsigned int mask = 0; + +- dbg(2, "%s: enter", __func__); +- + dev = file->private_data; + + if (!dev->udev) +@@ -571,8 +553,6 @@ static unsigned int tower_poll (struct f + mask |= POLLOUT | POLLWRNORM; + } + +- dbg(2, "%s: leave, mask = %d", __func__, mask); +- + return mask; + } + +@@ -597,8 +577,6 @@ static ssize_t tower_read (struct file * + int retval = 0; + unsigned long timeout = 0; + +- dbg(2, "%s: enter, count = %Zd", __func__, count); +- + dev = file->private_data; + + /* lock this object */ +@@ -672,7 +650,6 @@ unlock_exit: + mutex_unlock(&dev->lock); + + exit: +- dbg(2, "%s: leave, return value %d", __func__, retval); + return retval; + } + +@@ -686,8 +663,6 @@ static ssize_t tower_write (struct file + size_t bytes_to_write; + int retval = 0; + +- dbg(2, "%s: enter, count = %Zd", __func__, count); +- + dev = file->private_data; + + /* lock this object */ +@@ -757,8 +732,6 @@ unlock_exit: + mutex_unlock(&dev->lock); + + exit: +- dbg(2, "%s: leave, return value %d", __func__, retval); +- + return retval; + } + +@@ -772,8 +745,6 @@ static void tower_interrupt_in_callback + int status = urb->status; + int retval; + +- dbg(4, "%s: enter, status %d", __func__, status); +- + lego_usb_tower_debug_data(5, __func__, urb->actual_length, urb->transfer_buffer); + + if (status) { +@@ -817,7 +788,6 @@ exit: + wake_up_interruptible (&dev->read_wait); + + lego_usb_tower_debug_data(5, __func__, urb->actual_length, urb->transfer_buffer); +- dbg(4, "%s: leave, status %d", __func__, status); + } + + +@@ -829,7 +799,6 @@ static void tower_interrupt_out_callback + struct lego_usb_tower *dev = urb->context; + int status = urb->status; + +- 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 */ +@@ -844,7 +813,6 @@ static void tower_interrupt_out_callback + wake_up_interruptible(&dev->write_wait); + + lego_usb_tower_debug_data(5, __func__, urb->actual_length, urb->transfer_buffer); +- dbg(4, "%s: leave, status %d", __func__, status); + } + + +@@ -866,8 +834,6 @@ static int tower_probe (struct usb_inter + int retval = -ENOMEM; + int result; + +- dbg(2, "%s: enter", __func__); +- + /* allocate memory for our device state and initialize it */ + + dev = kmalloc (sizeof(struct lego_usb_tower), GFP_KERNEL); +@@ -993,8 +959,6 @@ static int tower_probe (struct usb_inter + + + exit: +- dbg(2, "%s: leave, return value 0x%.8lx (dev)", __func__, (long) dev); +- + return retval; + + error: +@@ -1013,8 +977,6 @@ static void tower_disconnect (struct usb + struct lego_usb_tower *dev; + int minor; + +- dbg(2, "%s: enter", __func__); +- + dev = usb_get_intfdata (interface); + mutex_lock(&open_disc_mutex); + usb_set_intfdata (interface, NULL); +@@ -1041,8 +1003,6 @@ static void tower_disconnect (struct usb + + dev_info(&interface->dev, "LEGO USB Tower #%d now disconnected\n", + (minor - LEGO_USB_TOWER_MINOR_BASE)); +- +- dbg(2, "%s: leave", __func__); + } + + module_usb_driver(tower_driver); diff --git a/applied/usb-legousbtower-remove-custom-debug-macro.patch b/applied/usb-legousbtower-remove-custom-debug-macro.patch new file mode 100644 index 00000000000000..20e64efbc0d07e --- /dev/null +++ b/applied/usb-legousbtower-remove-custom-debug-macro.patch @@ -0,0 +1,110 @@ +From foo@baz Wed Jun 26 16:16:21 PDT 2013 +Date: Wed, 26 Jun 2013 16:16:21 -0700 +To: Greg KH <gregkh@linuxfoundation.org>, Juergen Stuber <starblue@users.sourceforge.net> +Cc: linux-usb@vger.kernel.org +From: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +Subject: USB: legousbtower: remove custom debug macro + +Don't use a custom debug macro for just one driver, instead rely on the +in-kernel dynamic debugging logic, which can handle this much better. + +Cc: Juergen Stuber <starblue@users.sourceforge.net> +Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> + +--- + drivers/usb/misc/legousbtower.c | 27 +++++++++++++++------------ + 1 file changed, 15 insertions(+), 12 deletions(-) + +--- a/drivers/usb/misc/legousbtower.c ++++ b/drivers/usb/misc/legousbtower.c +@@ -443,7 +443,6 @@ static int tower_release (struct inode * + dev = file->private_data; + + if (dev == NULL) { +- dbg(1, "%s: object is NULL", __func__); + retval = -ENODEV; + goto exit_nolock; + } +@@ -455,7 +454,8 @@ static int tower_release (struct inode * + } + + if (dev->open_count != 1) { +- dbg(1, "%s: device not opened exactly once", __func__); ++ dev_dbg(&dev->udev->dev, "%s: device not opened exactly once\n", ++ __func__); + retval = -ENODEV; + goto unlock_exit; + } +@@ -491,10 +491,8 @@ exit_nolock: + */ + static void tower_abort_transfers (struct lego_usb_tower *dev) + { +- if (dev == NULL) { +- dbg(1, "%s: dev is null", __func__); ++ if (dev == NULL) + return; +- } + + /* shutdown transfer */ + if (dev->interrupt_in_running) { +@@ -594,7 +592,7 @@ static ssize_t tower_read (struct file * + + /* verify that we actually have some data to read */ + if (count == 0) { +- dbg(1, "%s: read request of 0 bytes", __func__); ++ dev_dbg(&dev->udev->dev, "read request of 0 bytes\n"); + goto unlock_exit; + } + +@@ -680,7 +678,7 @@ static ssize_t tower_write (struct file + + /* verify that we actually have some data to write */ + if (count == 0) { +- dbg(1, "%s: write request of 0 bytes", __func__); ++ dev_dbg(&dev->udev->dev, "write request of 0 bytes\n"); + goto unlock_exit; + } + +@@ -698,7 +696,8 @@ static ssize_t tower_write (struct file + + /* 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", __func__, count, bytes_to_write); ++ dev_dbg(&dev->udev->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; +@@ -753,7 +752,9 @@ static void tower_interrupt_in_callback + status == -ESHUTDOWN) { + goto exit; + } else { +- dbg(1, "%s: nonzero status received: %d", __func__, status); ++ dev_dbg(&dev->udev->dev, ++ "%s: nonzero status received: %d\n", __func__, ++ status); + goto resubmit; /* maybe we can recover */ + } + } +@@ -766,7 +767,8 @@ static void tower_interrupt_in_callback + urb->actual_length); + dev->read_buffer_length += urb->actual_length; + dev->read_last_arrival = jiffies; +- dbg(3, "%s: received %d bytes", __func__, urb->actual_length); ++ dev_dbg(&dev->udev->dev, "%s: received %d bytes\n", ++ __func__, urb->actual_length); + } else { + printk(KERN_WARNING "%s: read_buffer overflow, %d bytes dropped", __func__, urb->actual_length); + } +@@ -805,8 +807,9 @@ static void tower_interrupt_out_callback + if (status && !(status == -ENOENT || + status == -ECONNRESET || + status == -ESHUTDOWN)) { +- dbg(1, "%s - nonzero write bulk status received: %d", +- __func__, status); ++ dev_dbg(&dev->udev->dev, ++ "%s: nonzero write bulk status received: %d\n", __func__, ++ status); + } + + dev->interrupt_out_busy = 0; diff --git a/applied/usb-misc-remove-config_usb_debug-from-makefile.patch b/applied/usb-misc-remove-config_usb_debug-from-makefile.patch new file mode 100644 index 00000000000000..9ad231911543d0 --- /dev/null +++ b/applied/usb-misc-remove-config_usb_debug-from-makefile.patch @@ -0,0 +1,27 @@ +From foo@baz Wed Jun 26 16:23:51 PDT 2013 +Date: Wed, 26 Jun 2013 16:23:51 -0700 +To: Greg KH <gregkh@linuxfoundation.org> +From: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +Subject: USB: misc: remove CONFIG_USB_DEBUG from Makefile + +Now that no usb misc driver is looking for CONFIG_USB_DEBUG, or DEBUG, +don't enable it in the Makefile, as that's pointless. + +Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> + +--- + drivers/usb/misc/Makefile | 3 --- + 1 file changed, 3 deletions(-) + +--- a/drivers/usb/misc/Makefile ++++ b/drivers/usb/misc/Makefile +@@ -2,9 +2,6 @@ + # Makefile for the rest of the USB drivers + # (the ones that don't fit into any other categories) + # +- +-ccflags-$(CONFIG_USB_DEBUG) := -DDEBUG +- + obj-$(CONFIG_USB_ADUTUX) += adutux.o + obj-$(CONFIG_USB_APPLEDISPLAY) += appledisplay.o + obj-$(CONFIG_USB_CYPRESS_CY7C63) += cypress_cy7c63.o diff --git a/applied/usb-phy-remove-config_usb_debug-usage.patch b/applied/usb-phy-remove-config_usb_debug-usage.patch new file mode 100644 index 00000000000000..e30581cbf501a5 --- /dev/null +++ b/applied/usb-phy-remove-config_usb_debug-usage.patch @@ -0,0 +1,28 @@ +From foo@baz Fri Jun 28 11:10:15 PDT 2013 +Date: Fri, 28 Jun 2013 11:10:15 -0700 +To: Greg KH <gregkh@linuxfoundation.org> +Cc: Felipe Balbi <balbi@ti.com> +From: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +Subject: USB: phy: remove CONFIG_USB_DEBUG usage + +Now that no USB phy driver is using CONFIG_USB_DEBUG, remove it from the +Makefile. + +Cc: Felipe Balbi <balbi@ti.com> +Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +--- + drivers/usb/phy/Makefile | 3 --- + 1 file changed, 3 deletions(-) + +--- a/drivers/usb/phy/Makefile ++++ b/drivers/usb/phy/Makefile +@@ -1,9 +1,6 @@ + # + # Makefile for physical layer USB drivers + # +- +-ccflags-$(CONFIG_USB_DEBUG) := -DDEBUG +- + obj-$(CONFIG_USB_PHY) += phy.o + obj-$(CONFIG_OF) += of.o + diff --git a/applied/usb-phy-remove-custom-dbg-macro.patch b/applied/usb-phy-remove-custom-dbg-macro.patch new file mode 100644 index 00000000000000..603d7e91af778c --- /dev/null +++ b/applied/usb-phy-remove-custom-dbg-macro.patch @@ -0,0 +1,105 @@ +From foo@baz Fri Jun 28 11:08:22 PDT 2013 +Date: Fri, 28 Jun 2013 11:08:22 -0700 +To: Greg KH <gregkh@linuxfoundation.org> +Cc: Felipe Balbi <balbi@ti.com> +From: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +Subject: USB: phy: remove custom DBG macro + +Use the in-kernel pr_debug() calls instead of trying to roll your own +DBG macro. This means the dynamic debugging calls now work here, and +there is no dependency on CONFIG_USB_DEBUG for the phy code anymore. + +Cc: Felipe Balbi <balbi@ti.com> +Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> + +--- + +Note, this is against 3.10-rc7, odds are it will not apply to 3.11-rc1, +I'll refresh it when that is out and apply it then. + + drivers/usb/phy/phy-fsl-usb.c | 6 +++--- + drivers/usb/phy/phy-fsm-usb.h | 11 ++--------- + drivers/usb/phy/phy-isp1301-omap.c | 6 +----- + 3 files changed, 6 insertions(+), 17 deletions(-) + +--- a/drivers/usb/phy/phy-fsl-usb.c ++++ b/drivers/usb/phy/phy-fsl-usb.c +@@ -611,7 +611,7 @@ static int fsl_otg_set_peripheral(struct + otg_dev->fsm.b_bus_req = 1; + + /* start the gadget right away if the ID pin says Mini-B */ +- DBG("ID pin=%d\n", otg_dev->fsm.id); ++ pr_debug("ID pin=%d\n", otg_dev->fsm.id); + if (otg_dev->fsm.id == 1) { + fsl_otg_start_host(&otg_dev->fsm, 0); + otg_drv_vbus(&otg_dev->fsm, 0); +@@ -684,7 +684,7 @@ static int fsl_otg_start_hnp(struct usb_ + if (otg_dev != fsl_otg_dev) + return -ENODEV; + +- DBG("start_hnp...n"); ++ pr_debug("start_hnp...\n"); + + /* clear a_bus_req to enter a_suspend state */ + otg_dev->fsm.a_bus_req = 0; +@@ -941,7 +941,7 @@ int usb_otg_start(struct platform_device + p_otg->fsm.id = 0; + } + +- DBG("initial ID pin=%d\n", p_otg->fsm.id); ++ pr_debug("initial ID pin=%d\n", p_otg->fsm.id); + + /* enable OTG ID pin interrupt */ + temp = fsl_readl(&p_otg->dr_mem_map->otgsc); +--- a/drivers/usb/phy/phy-fsm-usb.h ++++ b/drivers/usb/phy/phy-fsm-usb.h +@@ -15,18 +15,11 @@ + * 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +-#undef DEBUG + #undef VERBOSE + +-#ifdef DEBUG +-#define DBG(fmt, args...) printk(KERN_DEBUG "[%s] " fmt , \ +- __func__, ## args) +-#else +-#define DBG(fmt, args...) do {} while (0) +-#endif +- + #ifdef VERBOSE +-#define VDBG DBG ++#define VDBG(fmt, args...) pr_debug("[%s] " fmt , \ ++ __func__, ## args) + #else + #define VDBG(stuff...) do {} while (0) + #endif +--- a/drivers/usb/phy/phy-isp1301-omap.c ++++ b/drivers/usb/phy/phy-isp1301-omap.c +@@ -40,9 +40,7 @@ + + #include <mach/usb.h> + +-#ifndef DEBUG +-#undef VERBOSE +-#endif ++#undef VERBOSE + + + #define DRIVER_VERSION "24 August 2004" +@@ -387,7 +385,6 @@ static void b_idle(struct isp1301 *isp, + static void + dump_regs(struct isp1301 *isp, const char *label) + { +-#ifdef DEBUG + u8 ctrl = isp1301_get_u8(isp, ISP1301_OTG_CONTROL_1); + u8 status = isp1301_get_u8(isp, ISP1301_OTG_STATUS); + u8 src = isp1301_get_u8(isp, ISP1301_INTERRUPT_SOURCE); +@@ -396,7 +393,6 @@ dump_regs(struct isp1301 *isp, const cha + omap_readl(OTG_CTRL), label, state_name(isp), + ctrl, status, src); + /* mode control and irq enables don't change much */ +-#endif + } + + /*-------------------------------------------------------------------------*/ diff --git a/applied/usb-remove-unneeded-idr.h-include.patch b/applied/usb-remove-unneeded-idr.h-include.patch new file mode 100644 index 00000000000000..3a5082c2d6b8cd --- /dev/null +++ b/applied/usb-remove-unneeded-idr.h-include.patch @@ -0,0 +1,36 @@ +From foo@baz Tue Jul 2 12:19:50 PDT 2013 +Date: Tue, 02 Jul 2013 12:19:50 -0700 +To: Greg KH <gregkh@linuxfoundation.org> +From: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +Subject: USB: remove unneeded idr.h include + +None of these USB files need idr.h, so don't include it. + +Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com> +Cc: Felipe Balbi <balbi@ti.com> +Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +--- + drivers/usb/core/endpoint.c | 1 - + drivers/usb/musb/musb_core.c | 1 - + 2 files changed, 2 deletions(-) + +--- a/drivers/usb/core/endpoint.c ++++ b/drivers/usb/core/endpoint.c +@@ -12,7 +12,6 @@ + #include <linux/kernel.h> + #include <linux/spinlock.h> + #include <linux/slab.h> +-#include <linux/idr.h> + #include <linux/usb.h> + #include "usb.h" + +--- a/drivers/usb/musb/musb_core.c ++++ b/drivers/usb/musb/musb_core.c +@@ -99,7 +99,6 @@ + #include <linux/prefetch.h> + #include <linux/platform_device.h> + #include <linux/io.h> +-#include <linux/idr.h> + #include <linux/dma-mapping.h> + + #include "musb_core.h" diff --git a/applied/usb-sl811-move-debug-files-from-proc-to-debugfs.patch b/applied/usb-sl811-move-debug-files-from-proc-to-debugfs.patch new file mode 100644 index 00000000000000..a18f57fd2a479f --- /dev/null +++ b/applied/usb-sl811-move-debug-files-from-proc-to-debugfs.patch @@ -0,0 +1,120 @@ +From foo@baz Tue Jul 2 12:18:43 PDT 2013 +Date: Tue, 02 Jul 2013 12:18:43 -0700 +To: Greg KH <gregkh@linuxfoundation.org> +From: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +Subject: USB: sl811: move debug files from proc to debugfs + +Drivers should not be putting debug files in /proc/ that is what debugfs +is for, so move the sl811 driver's debug file to debugfs. + +Cc: Felipe Balbi <balbi@ti.com> +Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> + +--- + drivers/usb/host/sl811-hcd.c | 38 +++++++++++--------------------------- + drivers/usb/host/sl811.h | 2 +- + 2 files changed, 12 insertions(+), 28 deletions(-) + +--- a/drivers/usb/host/sl811-hcd.c ++++ b/drivers/usb/host/sl811-hcd.c +@@ -48,6 +48,8 @@ + #include <linux/usb/hcd.h> + #include <linux/platform_device.h> + #include <linux/prefetch.h> ++#include <linux/debugfs.h> ++#include <linux/seq_file.h> + + #include <asm/io.h> + #include <asm/irq.h> +@@ -63,11 +65,6 @@ MODULE_ALIAS("platform:sl811-hcd"); + + #define DRIVER_VERSION "19 May 2005" + +- +-#ifndef DEBUG +-# define STUB_DEBUG_FILE +-#endif +- + /* for now, use only one transfer register bank */ + #undef USE_B + +@@ -1373,16 +1370,6 @@ sl811h_bus_resume(struct usb_hcd *hcd) + + /*-------------------------------------------------------------------------*/ + +-#ifdef STUB_DEBUG_FILE +- +-static inline void create_debug_file(struct sl811 *sl811) { } +-static inline void remove_debug_file(struct sl811 *sl811) { } +- +-#else +- +-#include <linux/proc_fs.h> +-#include <linux/seq_file.h> +- + static void dump_irq(struct seq_file *s, char *label, u8 mask) + { + seq_printf(s, "%s %02x%s%s%s%s%s%s\n", label, mask, +@@ -1394,7 +1381,7 @@ static void dump_irq(struct seq_file *s, + (mask & SL11H_INTMASK_DP) ? " dp" : ""); + } + +-static int proc_sl811h_show(struct seq_file *s, void *unused) ++static int sl811h_show(struct seq_file *s, void *unused) + { + struct sl811 *sl811 = s->private; + struct sl811h_ep *ep; +@@ -1505,34 +1492,31 @@ static int proc_sl811h_show(struct seq_f + return 0; + } + +-static int proc_sl811h_open(struct inode *inode, struct file *file) ++static int sl811h_open(struct inode *inode, struct file *file) + { +- return single_open(file, proc_sl811h_show, PDE_DATA(inode)); ++ return single_open(file, sl811h_show, inode->i_private); + } + +-static const struct file_operations proc_ops = { +- .open = proc_sl811h_open, ++static const struct file_operations debug_ops = { ++ .open = sl811h_open, + .read = seq_read, + .llseek = seq_lseek, + .release = single_release, + }; + + /* expect just one sl811 per system */ +-static const char proc_filename[] = "driver/sl811h"; +- + static void create_debug_file(struct sl811 *sl811) + { +- sl811->pde = proc_create_data(proc_filename, 0, NULL, &proc_ops, sl811); ++ sl811->debug_file = debugfs_create_file("sl811h", S_IRUGO, ++ usb_debug_root, sl811, ++ &debug_ops); + } + + static void remove_debug_file(struct sl811 *sl811) + { +- if (sl811->pde) +- remove_proc_entry(proc_filename, NULL); ++ debugfs_remove(sl811->debug_file); + } + +-#endif +- + /*-------------------------------------------------------------------------*/ + + static void +--- a/drivers/usb/host/sl811.h ++++ b/drivers/usb/host/sl811.h +@@ -122,7 +122,7 @@ struct sl811 { + void __iomem *addr_reg; + void __iomem *data_reg; + struct sl811_platform_data *board; +- struct proc_dir_entry *pde; ++ struct dentry *debug_file; + + unsigned long stat_insrmv; + unsigned long stat_wake; diff --git a/applied/usb-sl811-remove-config_usb_debug-dependency.patch b/applied/usb-sl811-remove-config_usb_debug-dependency.patch new file mode 100644 index 00000000000000..3da1ebf5f97738 --- /dev/null +++ b/applied/usb-sl811-remove-config_usb_debug-dependency.patch @@ -0,0 +1,308 @@ +From foo@baz Fri Jun 28 11:21:28 PDT 2013 +Date: Fri, 28 Jun 2013 11:21:28 -0700 +To: Greg KH <gregkh@linuxfoundation.org> +Cc: Felipe Balbi <balbi@ti.com> +From: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +Subject: USB: sl811: remove CONFIG_USB_DEBUG dependency + +This removes the dependency of the driver on CONFIG_USB_DEBUG and moves +it to us the dynamic debug subsystem instead. Bonus is the fact that we +can now properly determine the exact hardware that is spitting out the +messages. + +This lets debugging be enabled without having to rebuild the driver, an +important thing for users that can not do it. + +Cc: Felipe Balbi <balbi@ti.com> +Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> + +--- + drivers/usb/host/sl811-hcd.c | 69 +++++++++++++++++++++++++------------------ + drivers/usb/host/sl811.h | 19 ----------- + 2 files changed, 42 insertions(+), 46 deletions(-) + +--- a/drivers/usb/host/sl811-hcd.c ++++ b/drivers/usb/host/sl811-hcd.c +@@ -100,7 +100,8 @@ static void port_power(struct sl811 *sl8 + + if (sl811->board && sl811->board->port_power) { + /* switch VBUS, at 500mA unless hub power budget gets set */ +- DBG("power %s\n", is_on ? "on" : "off"); ++ dev_dbg(hcd->self.controller, "power %s\n", ++ is_on ? "on" : "off"); + sl811->board->port_power(hcd->self.controller, is_on); + } + +@@ -282,7 +283,7 @@ static inline void sofirq_on(struct sl81 + { + if (sl811->irq_enable & SL11H_INTMASK_SOFINTR) + return; +- VDBG("sof irq on\n"); ++ dev_dbg(sl811_to_hcd(sl811)->self.controller, "sof irq on\n"); + sl811->irq_enable |= SL11H_INTMASK_SOFINTR; + } + +@@ -290,7 +291,7 @@ static inline void sofirq_off(struct sl8 + { + if (!(sl811->irq_enable & SL11H_INTMASK_SOFINTR)) + return; +- VDBG("sof irq off\n"); ++ dev_dbg(sl811_to_hcd(sl811)->self.controller, "sof irq off\n"); + sl811->irq_enable &= ~SL11H_INTMASK_SOFINTR; + } + +@@ -338,7 +339,8 @@ static struct sl811h_ep *start(struct sl + } + + if (unlikely(list_empty(&ep->hep->urb_list))) { +- DBG("empty %p queue?\n", ep); ++ dev_dbg(sl811_to_hcd(sl811)->self.controller, ++ "empty %p queue?\n", ep); + return NULL; + } + +@@ -391,7 +393,8 @@ static struct sl811h_ep *start(struct sl + status_packet(sl811, ep, urb, bank, control); + break; + default: +- DBG("bad ep%p pid %02x\n", ep, ep->nextpid); ++ dev_dbg(sl811_to_hcd(sl811)->self.controller, ++ "bad ep%p pid %02x\n", ep, ep->nextpid); + ep = NULL; + } + return ep; +@@ -447,7 +450,8 @@ static void finish_request( + } + + /* periodic deschedule */ +- DBG("deschedule qh%d/%p branch %d\n", ep->period, ep, ep->branch); ++ dev_dbg(sl811_to_hcd(sl811)->self.controller, ++ "deschedule qh%d/%p branch %d\n", ep->period, ep, ep->branch); + for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) { + struct sl811h_ep *temp; + struct sl811h_ep **prev = &sl811->periodic[i]; +@@ -593,7 +597,8 @@ static inline u8 checkdone(struct sl811 + ctl = sl811_read(sl811, SL811_EP_A(SL11H_HOSTCTLREG)); + if (ctl & SL11H_HCTLMASK_ARM) + sl811_write(sl811, SL811_EP_A(SL11H_HOSTCTLREG), 0); +- DBG("%s DONE_A: ctrl %02x sts %02x\n", ++ dev_dbg(sl811_to_hcd(sl811)->self.controller, ++ "%s DONE_A: ctrl %02x sts %02x\n", + (ctl & SL11H_HCTLMASK_ARM) ? "timeout" : "lost", + ctl, + sl811_read(sl811, SL811_EP_A(SL11H_PKTSTATREG))); +@@ -604,7 +609,8 @@ static inline u8 checkdone(struct sl811 + ctl = sl811_read(sl811, SL811_EP_B(SL11H_HOSTCTLREG)); + if (ctl & SL11H_HCTLMASK_ARM) + sl811_write(sl811, SL811_EP_B(SL11H_HOSTCTLREG), 0); +- DBG("%s DONE_B: ctrl %02x sts %02x\n", ++ dev_dbg(sl811_to_hcd(sl811)->self.controller, ++ "%s DONE_B: ctrl %02x sts %02x\n", + (ctl & SL11H_HCTLMASK_ARM) ? "timeout" : "lost", + ctl, + sl811_read(sl811, SL811_EP_B(SL11H_PKTSTATREG))); +@@ -665,7 +671,7 @@ retry: + * this one has nothing scheduled. + */ + if (sl811->next_periodic) { +- // ERR("overrun to slot %d\n", index); ++ // dev_err(hcd->self.controller, "overrun to slot %d\n", index); + sl811->stat_overrun++; + } + if (sl811->periodic[index]) +@@ -723,7 +729,7 @@ retry: + + } else if (irqstat & SL11H_INTMASK_RD) { + if (sl811->port1 & USB_PORT_STAT_SUSPEND) { +- DBG("wakeup\n"); ++ dev_dbg(hcd->self.controller, "wakeup\n"); + sl811->port1 |= USB_PORT_STAT_C_SUSPEND << 16; + sl811->stat_wake++; + } else +@@ -852,8 +858,9 @@ static int sl811h_urb_enqueue( + + if (ep->maxpacket > H_MAXPACKET) { + /* iso packets up to 240 bytes could work... */ +- DBG("dev %d ep%d maxpacket %d\n", +- udev->devnum, epnum, ep->maxpacket); ++ dev_dbg(hcd->self.controller, ++ "dev %d ep%d maxpacket %d\n", udev->devnum, ++ epnum, ep->maxpacket); + retval = -EINVAL; + kfree(ep); + goto fail; +@@ -917,7 +924,8 @@ static int sl811h_urb_enqueue( + * to share the faster parts of the tree without needing + * dummy/placeholder nodes + */ +- DBG("schedule qh%d/%p branch %d\n", ep->period, ep, ep->branch); ++ dev_dbg(hcd->self.controller, "schedule qh%d/%p branch %d\n", ++ ep->period, ep, ep->branch); + for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) { + struct sl811h_ep **prev = &sl811->periodic[i]; + struct sl811h_ep *here = *prev; +@@ -976,7 +984,8 @@ static int sl811h_urb_dequeue(struct usb + } else if (sl811->active_a == ep) { + if (time_before_eq(sl811->jiffies_a, jiffies)) { + /* happens a lot with lowspeed?? */ +- DBG("giveup on DONE_A: ctrl %02x sts %02x\n", ++ dev_dbg(hcd->self.controller, ++ "giveup on DONE_A: ctrl %02x sts %02x\n", + sl811_read(sl811, + SL811_EP_A(SL11H_HOSTCTLREG)), + sl811_read(sl811, +@@ -990,7 +999,8 @@ static int sl811h_urb_dequeue(struct usb + } else if (sl811->active_b == ep) { + if (time_before_eq(sl811->jiffies_a, jiffies)) { + /* happens a lot with lowspeed?? */ +- DBG("giveup on DONE_B: ctrl %02x sts %02x\n", ++ dev_dbg(hcd->self.controller, ++ "giveup on DONE_B: ctrl %02x sts %02x\n", + sl811_read(sl811, + SL811_EP_B(SL11H_HOSTCTLREG)), + sl811_read(sl811, +@@ -1008,7 +1018,8 @@ static int sl811h_urb_dequeue(struct usb + if (urb) + finish_request(sl811, ep, urb, 0); + else +- VDBG("dequeue, urb %p active %s; wait4irq\n", urb, ++ dev_dbg(sl811_to_hcd(sl811)->self.controller, ++ "dequeue, urb %p active %s; wait4irq\n", urb, + (sl811->active_a == ep) ? "A" : "B"); + } else + retval = -EINVAL; +@@ -1029,7 +1040,7 @@ sl811h_endpoint_disable(struct usb_hcd * + if (!list_empty(&hep->urb_list)) + msleep(3); + if (!list_empty(&hep->urb_list)) +- WARNING("ep %p not empty?\n", ep); ++ dev_warn(hcd->self.controller, "ep %p not empty?\n", ep); + + kfree(ep); + hep->hcpriv = NULL; +@@ -1132,7 +1143,7 @@ sl811h_timer(unsigned long _sl811) + + switch (signaling) { + case SL11H_CTL1MASK_SE0: +- DBG("end reset\n"); ++ dev_dbg(sl811_to_hcd(sl811)->self.controller, "end reset\n"); + sl811->port1 = (USB_PORT_STAT_C_RESET << 16) + | USB_PORT_STAT_POWER; + sl811->ctrl1 = 0; +@@ -1141,11 +1152,12 @@ sl811h_timer(unsigned long _sl811) + irqstat &= ~SL11H_INTMASK_RD; + break; + case SL11H_CTL1MASK_K: +- DBG("end resume\n"); ++ dev_dbg(sl811_to_hcd(sl811)->self.controller, "end resume\n"); + sl811->port1 &= ~USB_PORT_STAT_SUSPEND; + break; + default: +- DBG("odd timer signaling: %02x\n", signaling); ++ dev_dbg(sl811_to_hcd(sl811)->self.controller, ++ "odd timer signaling: %02x\n", signaling); + break; + } + sl811_write(sl811, SL11H_IRQ_STATUS, irqstat); +@@ -1243,7 +1255,7 @@ sl811h_hub_control( + break; + + /* 20 msec of resume/K signaling, other irqs blocked */ +- DBG("start resume...\n"); ++ dev_dbg(hcd->self.controller, "start resume...\n"); + sl811->irq_enable = 0; + sl811_write(sl811, SL11H_IRQ_ENABLE, + sl811->irq_enable); +@@ -1281,7 +1293,8 @@ sl811h_hub_control( + #ifndef VERBOSE + if (*(u16*)(buf+2)) /* only if wPortChange is interesting */ + #endif +- DBG("GetPortStatus %08x\n", sl811->port1); ++ dev_dbg(hcd->self.controller, "GetPortStatus %08x\n", ++ sl811->port1); + break; + case SetPortFeature: + if (wIndex != 1 || wLength != 0) +@@ -1293,7 +1306,7 @@ sl811h_hub_control( + if (!(sl811->port1 & USB_PORT_STAT_ENABLE)) + goto error; + +- DBG("suspend...\n"); ++ dev_dbg(hcd->self.controller,"suspend...\n"); + sl811->ctrl1 &= ~SL11H_CTL1MASK_SOF_ENA; + sl811_write(sl811, SL11H_CTLREG1, sl811->ctrl1); + break; +@@ -1338,7 +1351,7 @@ static int + sl811h_bus_suspend(struct usb_hcd *hcd) + { + // SOFs off +- DBG("%s\n", __func__); ++ dev_dbg(hcd->self.controller, "%s\n", __func__); + return 0; + } + +@@ -1346,7 +1359,7 @@ static int + sl811h_bus_resume(struct usb_hcd *hcd) + { + // SOFs on +- DBG("%s\n", __func__); ++ dev_dbg(hcd->self.controller, "%s\n", __func__); + return 0; + } + +@@ -1648,7 +1661,7 @@ sl811h_probe(struct platform_device *dev + + /* refuse to confuse usbcore */ + if (dev->dev.dma_mask) { +- DBG("no we won't dma\n"); ++ dev_dbg(&dev->dev, "no we won't dma\n"); + return -EINVAL; + } + +@@ -1716,7 +1729,7 @@ sl811h_probe(struct platform_device *dev + break; + default: + /* reject case 0, SL11S is less functional */ +- DBG("chiprev %02x\n", tmp); ++ dev_dbg(&dev->dev, "chiprev %02x\n", tmp); + retval = -ENXIO; + goto err6; + } +@@ -1747,7 +1760,7 @@ sl811h_probe(struct platform_device *dev + if (!ioaddr) + iounmap(addr_reg); + err2: +- DBG("init error, %d\n", retval); ++ dev_dbg(&dev->dev, "init error, %d\n", retval); + return retval; + } + +--- a/drivers/usb/host/sl811.h ++++ b/drivers/usb/host/sl811.h +@@ -242,25 +242,8 @@ sl811_read_buf(struct sl811 *sl811, int + + /*-------------------------------------------------------------------------*/ + +-#ifdef DEBUG +-#define DBG(stuff...) printk(KERN_DEBUG "sl811: " stuff) +-#else +-#define DBG(stuff...) do{}while(0) +-#endif +- +-#ifdef VERBOSE +-# define VDBG DBG +-#else +-# define VDBG(stuff...) do{}while(0) +-#endif +- + #ifdef PACKET_TRACE +-# define PACKET VDBG ++# define PACKET pr_debug("sl811: "stuff) + #else + # define PACKET(stuff...) do{}while(0) + #endif +- +-#define ERR(stuff...) printk(KERN_ERR "sl811: " stuff) +-#define WARNING(stuff...) printk(KERN_WARNING "sl811: " stuff) +-#define INFO(stuff...) printk(KERN_INFO "sl811: " stuff) +- diff --git a/applied/usb-usbatm-don-t-rely-on-config_usb_debug.patch b/applied/usb-usbatm-don-t-rely-on-config_usb_debug.patch new file mode 100644 index 00000000000000..dc6ff519a37a32 --- /dev/null +++ b/applied/usb-usbatm-don-t-rely-on-config_usb_debug.patch @@ -0,0 +1,40 @@ +From foo@baz Fri Jun 28 11:03:03 PDT 2013 +Date: Fri, 28 Jun 2013 11:03:03 -0700 +To: Greg KH <gregkh@linuxfoundation.org> +Cc: Duncan Sands <duncan.sands@free.fr> +From: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +Subject: USB: usbatm: don't rely on CONFIG_USB_DEBUG + +Enable the USB atm drivers to use the dynamic debugging subsystem, and +not rely on if CONFIG_USB_DEBUG is enabled or not for debugging +messages. This also provides a saner debug message, pointing out the +exact device the message is coming from. + +This also means the drivers do not have to be rebuilt to get debugging +messages, important for getting information from users who can not +rebuild their kernels. + +Cc: Duncan Sands <duncan.sands@free.fr> +Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> + +--- + drivers/usb/atm/usbatm.h | 7 +------ + 1 file changed, 1 insertion(+), 6 deletions(-) + +--- a/drivers/usb/atm/usbatm.h ++++ b/drivers/usb/atm/usbatm.h +@@ -45,13 +45,8 @@ + dev_info(&(instance)->usb_intf->dev , format , ## arg) + #define usb_warn(instance, format, arg...) \ + dev_warn(&(instance)->usb_intf->dev , format , ## arg) +-#ifdef DEBUG + #define usb_dbg(instance, format, arg...) \ +- dev_printk(KERN_DEBUG , &(instance)->usb_intf->dev , format , ## arg) +-#else +-#define usb_dbg(instance, format, arg...) \ +- do {} while (0) +-#endif ++ dev_dbg(&(instance)->usb_intf->dev , format , ## arg) + + /* FIXME: move to dev_* once ATM is driver model aware */ + #define atm_printk(level, instance, format, arg...) \ diff --git a/applied/usb-usbatm-move-the-atm_dbg-call-to-use-dynamic-debug.patch b/applied/usb-usbatm-move-the-atm_dbg-call-to-use-dynamic-debug.patch new file mode 100644 index 00000000000000..e2b15aa5168699 --- /dev/null +++ b/applied/usb-usbatm-move-the-atm_dbg-call-to-use-dynamic-debug.patch @@ -0,0 +1,46 @@ +From foo@baz Fri Jun 28 11:04:33 PDT 2013 +Date: Fri, 28 Jun 2013 11:04:33 -0700 +To: Greg KH <gregkh@linuxfoundation.org> +Cc: Duncan Sands <duncan.sands@free.fr> +From: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +Subject: USB: usbatm: move the atm_dbg() call to use dynamic debug + +Move the atm_dbg() call to use the dynamic debug subsystem, and not rely +on CONFIG_USB_DEBUG for if things should be printed out or not. + +This also means the drivers do not have to be rebuilt to get debugging +messages, important for getting information from users who can not +rebuild their kernels. + +Cc: Duncan Sands <duncan.sands@free.fr> +Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +--- + drivers/usb/atm/usbatm.h | 16 +++++----------- + 1 file changed, 5 insertions(+), 11 deletions(-) + +--- a/drivers/usb/atm/usbatm.h ++++ b/drivers/usb/atm/usbatm.h +@@ -59,18 +59,12 @@ + atm_printk(KERN_INFO, instance , format , ## arg) + #define atm_warn(instance, format, arg...) \ + atm_printk(KERN_WARNING, instance , format , ## arg) +-#ifdef DEBUG +-#define atm_dbg(instance, format, arg...) \ +- atm_printk(KERN_DEBUG, instance , format , ## arg) +-#define atm_rldbg(instance, format, arg...) \ ++#define atm_dbg(instance, format, arg...) \ ++ dynamic_pr_debug("ATM dev %d: " format , \ ++ (instance)->atm_dev->number , ## arg) ++#define atm_rldbg(instance, format, arg...) \ + if (printk_ratelimit()) \ +- atm_printk(KERN_DEBUG, instance , format , ## arg) +-#else +-#define atm_dbg(instance, format, arg...) \ +- do {} while (0) +-#define atm_rldbg(instance, format, arg...) \ +- do {} while (0) +-#endif ++ atm_dbg(instance , format , ## arg) + + + /* flags, set by mini-driver in bind() */ diff --git a/applied/usb-usbatm-remove-config_usb_debug-dependancy.patch b/applied/usb-usbatm-remove-config_usb_debug-dependancy.patch new file mode 100644 index 00000000000000..3d22ffa838db00 --- /dev/null +++ b/applied/usb-usbatm-remove-config_usb_debug-dependancy.patch @@ -0,0 +1,63 @@ +From foo@baz Fri Jun 28 11:06:30 PDT 2013 +Date: Fri, 28 Jun 2013 11:06:30 -0700 +To: Greg KH <gregkh@linuxfoundation.org> +Cc: Duncan Sands <duncan.sands@free.fr> +From: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +Subject: USB: usbatm: remove CONFIG_USB_DEBUG dependancy + +Now that no USB atm driver is relying on the CONFIG_USB_DEBUG option +(well, really the DEBUG option, thanks to some Makefile fun), remove it +from the Makefile. + +Also remove two last vestiges of DEBUG in the usbatm.c driver, moving +one to VERBOSE_DEBUG, which no one ever really cares about, and the +other to use the dynamic debug subsystem. + +Cc: Duncan Sands <duncan.sands@free.fr> +Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> + +--- + drivers/usb/atm/Makefile | 3 --- + drivers/usb/atm/usbatm.c | 7 +++---- + 2 files changed, 3 insertions(+), 7 deletions(-) + +--- a/drivers/usb/atm/Makefile ++++ b/drivers/usb/atm/Makefile +@@ -1,9 +1,6 @@ + # + # Makefile for USB ATM/xDSL drivers + # +- +-ccflags-$(CONFIG_USB_DEBUG) := -DDEBUG +- + obj-$(CONFIG_USB_CXACRU) += cxacru.o + obj-$(CONFIG_USB_SPEEDTOUCH) += speedtch.o + obj-$(CONFIG_USB_UEAGLEATM) += ueagle-atm.o +--- a/drivers/usb/atm/usbatm.c ++++ b/drivers/usb/atm/usbatm.c +@@ -661,7 +661,7 @@ static int usbatm_atm_send(struct atm_vc + + /* racy disconnection check - fine */ + if (!instance || instance->disconnected) { +-#ifdef DEBUG ++#ifdef VERBOSE_DEBUG + printk_ratelimited(KERN_DEBUG "%s: %s!\n", __func__, instance ? "disconnected" : "NULL instance"); + #endif + err = -ENODEV; +@@ -1120,14 +1120,13 @@ int usbatm_usb_probe(struct usb_interfac + instance->rx_channel.buf_size = num_packets * maxpacket; + instance->rx_channel.packet_size = maxpacket; + +-#ifdef DEBUG + for (i = 0; i < 2; i++) { + struct usbatm_channel *channel = i ? + &instance->tx_channel : &instance->rx_channel; + +- dev_dbg(dev, "%s: using %d byte buffer for %s channel 0x%p\n", __func__, channel->buf_size, i ? "tx" : "rx", channel); ++ dev_dbg(dev, "%s: using %d byte buffer for %s channel 0x%p\n", ++ __func__, channel->buf_size, i ? "tx" : "rx", channel); + } +-#endif + + /* initialize urbs */ + diff --git a/applied/usb-usbatm-remove-unneeded-trace-printk-calls.patch b/applied/usb-usbatm-remove-unneeded-trace-printk-calls.patch new file mode 100644 index 00000000000000..47744072df983c --- /dev/null +++ b/applied/usb-usbatm-remove-unneeded-trace-printk-calls.patch @@ -0,0 +1,149 @@ +From foo@baz Fri Jun 28 11:02:03 PDT 2013 +Date: Fri, 28 Jun 2013 11:02:03 -0700 +To: Greg KH <gregkh@linuxfoundation.org> +Cc: Duncan Sands <duncan.sands@free.fr> +From: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +Subject: USB: usbatm: remove unneeded trace printk calls + +We have an in-kernel trace subsystem, so use that instead of printk for +trying to figure out what functions are being called. + +Cc: Duncan Sands <duncan.sands@free.fr> +Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> + +--- + drivers/usb/atm/usbatm.c | 34 ---------------------------------- + 1 file changed, 34 deletions(-) + +--- a/drivers/usb/atm/usbatm.c ++++ b/drivers/usb/atm/usbatm.c +@@ -311,8 +311,6 @@ static void usbatm_extract_one_cell(stru + int vci = ((source[1] & 0x0f) << 12) | (source[2] << 4) | (source[3] >> 4); + u8 pti = ((source[3] & 0xe) >> 1); + +- vdbg(&instance->usb_intf->dev, "%s: vpi %hd, vci %d, pti %d", __func__, vpi, vci, pti); +- + if ((vci != instance->cached_vci) || (vpi != instance->cached_vpi)) { + instance->cached_vpi = vpi; + instance->cached_vci = vci; +@@ -476,9 +474,6 @@ static unsigned int usbatm_write_cells(s + unsigned int bytes_written; + unsigned int stride = instance->tx_channel.stride; + +- vdbg(&instance->usb_intf->dev, "%s: skb->len=%d, avail_space=%u", +- __func__, skb->len, avail_space); +- + for (bytes_written = 0; bytes_written < avail_space && ctrl->len; + bytes_written += stride, target += stride) { + unsigned int data_len = min_t(unsigned int, skb->len, ATM_CELL_PAYLOAD); +@@ -639,7 +634,6 @@ static void usbatm_cancel_send(struct us + { + struct sk_buff *skb, *n; + +- atm_dbg(instance, "%s entered\n", __func__); + spin_lock_irq(&instance->sndqueue.lock); + skb_queue_walk_safe(&instance->sndqueue, skb, n) { + if (UDSL_SKB(skb)->atm.vcc == vcc) { +@@ -657,7 +651,6 @@ static void usbatm_cancel_send(struct us + usbatm_pop(vcc, skb); + } + tasklet_enable(&instance->tx_channel.tasklet); +- atm_dbg(instance, "%s done\n", __func__); + } + + static int usbatm_atm_send(struct atm_vcc *vcc, struct sk_buff *skb) +@@ -675,9 +668,6 @@ static int usbatm_atm_send(struct atm_vc + goto fail; + } + +- vdbg(&instance->usb_intf->dev, "%s called (skb 0x%p, len %u)", __func__, +- skb, skb->len); +- + if (vcc->qos.aal != ATM_AAL5) { + atm_rldbg(instance, "%s: unsupported ATM type %d!\n", __func__, vcc->qos.aal); + err = -EINVAL; +@@ -717,8 +707,6 @@ static void usbatm_destroy_instance(stru + { + struct usbatm_data *instance = container_of(kref, struct usbatm_data, refcount); + +- usb_dbg(instance, "%s\n", __func__); +- + tasklet_kill(&instance->rx_channel.tasklet); + tasklet_kill(&instance->tx_channel.tasklet); + usb_put_dev(instance->usb_dev); +@@ -727,15 +715,11 @@ static void usbatm_destroy_instance(stru + + static void usbatm_get_instance(struct usbatm_data *instance) + { +- usb_dbg(instance, "%s\n", __func__); +- + kref_get(&instance->refcount); + } + + static void usbatm_put_instance(struct usbatm_data *instance) + { +- usb_dbg(instance, "%s\n", __func__); +- + kref_put(&instance->refcount, usbatm_destroy_instance); + } + +@@ -751,7 +735,6 @@ static void usbatm_atm_dev_close(struct + if (!instance) + return; + +- usb_dbg(instance, "%s\n", __func__); + atm_dev->dev_data = NULL; /* catch bugs */ + usbatm_put_instance(instance); /* taken in usbatm_atm_init */ + } +@@ -807,8 +790,6 @@ static int usbatm_atm_open(struct atm_vc + if (!instance) + return -ENODEV; + +- atm_dbg(instance, "%s: vpi %hd, vci %d\n", __func__, vpi, vci); +- + /* only support AAL5 */ + if ((vcc->qos.aal != ATM_AAL5)) { + atm_warn(instance, "%s: unsupported ATM type %d!\n", __func__, vcc->qos.aal); +@@ -885,11 +866,6 @@ static void usbatm_atm_close(struct atm_ + if (!instance || !vcc_data) + return; + +- atm_dbg(instance, "%s entered\n", __func__); +- +- atm_dbg(instance, "%s: deallocating vcc 0x%p with vpi %d vci %d\n", +- __func__, vcc_data, vcc_data->vpi, vcc_data->vci); +- + usbatm_cancel_send(instance, vcc); + + mutex_lock(&instance->serialize); /* vs self, usbatm_atm_open, usbatm_usb_disconnect */ +@@ -916,8 +892,6 @@ static void usbatm_atm_close(struct atm_ + clear_bit(ATM_VF_ADDR, &vcc->flags); + + mutex_unlock(&instance->serialize); +- +- atm_dbg(instance, "%s successful\n", __func__); + } + + static int usbatm_atm_ioctl(struct atm_dev *atm_dev, unsigned int cmd, +@@ -1054,12 +1028,6 @@ int usbatm_usb_probe(struct usb_interfac + int i, length; + unsigned int maxpacket, num_packets; + +- dev_dbg(dev, "%s: trying driver %s with vendor=%04x, product=%04x, ifnum %2d\n", +- __func__, driver->driver_name, +- le16_to_cpu(usb_dev->descriptor.idVendor), +- le16_to_cpu(usb_dev->descriptor.idProduct), +- intf->altsetting->desc.bInterfaceNumber); +- + /* instance init */ + instance = kzalloc(sizeof(*instance) + sizeof(struct urb *) * (num_rcv_urbs + num_snd_urbs), GFP_KERNEL); + if (!instance) { +@@ -1258,8 +1226,6 @@ void usbatm_usb_disconnect(struct usb_in + struct usbatm_vcc_data *vcc_data; + int i; + +- dev_dbg(dev, "%s entered\n", __func__); +- + if (!instance) { + dev_dbg(dev, "%s: NULL instance!\n", __func__); + return; diff --git a/applied/usb-usbatm-remove-unused-udsl_assert-macro.patch b/applied/usb-usbatm-remove-unused-udsl_assert-macro.patch new file mode 100644 index 00000000000000..38b083e56f607f --- /dev/null +++ b/applied/usb-usbatm-remove-unused-udsl_assert-macro.patch @@ -0,0 +1,85 @@ +From foo@baz Fri Jun 28 11:00:13 PDT 2013 +Date: Fri, 28 Jun 2013 11:00:13 -0700 +To: Greg KH <gregkh@linuxfoundation.org> +Cc: Duncan Sands <duncan.sands@free.fr> +From: Greg Kroah-Hartman <gregkh@linuxfoundation.org> +Subject: USB: usbatm: remove unused UDSL_ASSERT macro + +If this code isn't triggering this assert by now, it never will, so just +remove it, it's pointless. + +Cc: Duncan Sands <duncan.sands@free.fr> +Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> + + +--- + drivers/usb/atm/usbatm.c | 8 -------- + drivers/usb/atm/usbatm.h | 12 ------------ + 2 files changed, 20 deletions(-) + +--- a/drivers/usb/atm/usbatm.c ++++ b/drivers/usb/atm/usbatm.c +@@ -344,7 +344,6 @@ static void usbatm_extract_one_cell(stru + __func__, sarb->len, vcc); + /* discard cells already received */ + skb_trim(sarb, 0); +- UDSL_ASSERT(instance, sarb->tail + ATM_CELL_PAYLOAD <= sarb->end); + } + + memcpy(skb_tail_pointer(sarb), source + ATM_CELL_HEADER, ATM_CELL_PAYLOAD); +@@ -437,8 +436,6 @@ static void usbatm_extract_cells(struct + unsigned char *cell_buf = instance->cell_buf; + unsigned int space_left = stride - buf_usage; + +- UDSL_ASSERT(instance, buf_usage <= stride); +- + if (avail_data >= space_left) { + /* add new data and process cell */ + memcpy(cell_buf + buf_usage, source, space_left); +@@ -481,7 +478,6 @@ static unsigned int usbatm_write_cells(s + + vdbg(&instance->usb_intf->dev, "%s: skb->len=%d, avail_space=%u", + __func__, skb->len, avail_space); +- UDSL_ASSERT(instance, !(avail_space % stride)); + + for (bytes_written = 0; bytes_written < avail_space && ctrl->len; + bytes_written += stride, target += stride) { +@@ -553,8 +549,6 @@ static void usbatm_rx_process(unsigned l + if (!urb->iso_frame_desc[i].status) { + unsigned int actual_length = urb->iso_frame_desc[i].actual_length; + +- UDSL_ASSERT(instance, actual_length <= packet_size); +- + if (!merge_length) + merge_start = (unsigned char *)urb->transfer_buffer + urb->iso_frame_desc[i].offset; + merge_length += actual_length; +@@ -1176,8 +1170,6 @@ int usbatm_usb_probe(struct usb_interfac + struct urb *urb; + unsigned int iso_packets = usb_pipeisoc(channel->endpoint) ? channel->buf_size / channel->packet_size : 0; + +- UDSL_ASSERT(instance, !usb_pipeisoc(channel->endpoint) || usb_pipein(channel->endpoint)); +- + urb = usb_alloc_urb(iso_packets, GFP_KERNEL); + if (!urb) { + dev_err(dev, "%s: no memory for urb %d!\n", __func__, i); +--- a/drivers/usb/atm/usbatm.h ++++ b/drivers/usb/atm/usbatm.h +@@ -39,18 +39,6 @@ + #define VERBOSE_DEBUG + */ + +-#ifdef DEBUG +-#define UDSL_ASSERT(instance, x) BUG_ON(!(x)) +-#else +-#define UDSL_ASSERT(instance, x) \ +- do { \ +- if (!(x)) \ +- dev_warn(&(instance)->usb_intf->dev, \ +- "failed assertion '%s' at line %d", \ +- __stringify(x), __LINE__); \ +- } while (0) +-#endif +- + #define usb_err(instance, format, arg...) \ + dev_err(&(instance)->usb_intf->dev , format , ## arg) + #define usb_info(instance, format, arg...) \ |