diff options
Diffstat (limited to 'drivers')
64 files changed, 474 insertions, 430 deletions
diff --git a/drivers/i2c/chips/it87.c b/drivers/i2c/chips/it87.c index 3d484a7aff1..cf7e6898754 100644 --- a/drivers/i2c/chips/it87.c +++ b/drivers/i2c/chips/it87.c @@ -668,7 +668,7 @@ static ssize_t show_alarms(struct device *dev, char *buf) struct it87_data *data = it87_update_device(dev); return sprintf(buf,"%d\n", ALARMS_FROM_REG(data->alarms)); } -static DEVICE_ATTR(alarms, S_IRUGO | S_IWUSR, show_alarms, NULL); +static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL); static ssize_t show_vrm_reg(struct device *dev, char *buf) diff --git a/drivers/i2c/chips/via686a.c b/drivers/i2c/chips/via686a.c index 9b948f4531f..6614a59cecd 100644 --- a/drivers/i2c/chips/via686a.c +++ b/drivers/i2c/chips/via686a.c @@ -574,7 +574,7 @@ static ssize_t show_alarms(struct device *dev, char *buf) { struct via686a_data *data = via686a_update_device(dev); return sprintf(buf,"%d\n", ALARMS_FROM_REG(data->alarms)); } -static DEVICE_ATTR(alarms, S_IRUGO | S_IWUSR, show_alarms, NULL); +static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL); /* The driver. I choose to use type i2c_driver, as at is identical to both smbus_driver and isa_driver, and clients could be of either kind */ @@ -651,10 +651,9 @@ static int via686a_detect(struct i2c_adapter *adapter, int address, int kind) new_client->adapter = adapter; new_client->driver = &via686a_driver; new_client->flags = 0; - new_client->dev.parent = &adapter->dev; /* Fill in the remaining client fields and put into the global list */ - snprintf(new_client->name, I2C_NAME_SIZE, client_name); + strlcpy(new_client->name, client_name, I2C_NAME_SIZE); data->valid = 0; init_MUTEX(&data->update_lock); diff --git a/drivers/net/irda/stir4200.c b/drivers/net/irda/stir4200.c index 83c605e8824..66f488c1371 100644 --- a/drivers/net/irda/stir4200.c +++ b/drivers/net/irda/stir4200.c @@ -1128,8 +1128,8 @@ static void stir_disconnect(struct usb_interface *intf) } #ifdef CONFIG_PM -/* Power management suspend, so power off the transmitter/receiver */ -static int stir_suspend(struct usb_interface *intf, u32 state) +/* USB suspend, so power off the transmitter/receiver */ +static int stir_suspend(struct usb_interface *intf, pm_message_t message) { struct stir_cb *stir = usb_get_intfdata(intf); diff --git a/drivers/usb/class/audio.c b/drivers/usb/class/audio.c index f432b7d5b23..f8f21567cc2 100644 --- a/drivers/usb/class/audio.c +++ b/drivers/usb/class/audio.c @@ -649,14 +649,10 @@ static void usbin_stop(struct usb_audiodev *as) } } set_current_state(TASK_RUNNING); - if (u->durb[0].urb->transfer_buffer) - kfree(u->durb[0].urb->transfer_buffer); - if (u->durb[1].urb->transfer_buffer) - kfree(u->durb[1].urb->transfer_buffer); - if (u->surb[0].urb->transfer_buffer) - kfree(u->surb[0].urb->transfer_buffer); - if (u->surb[1].urb->transfer_buffer) - kfree(u->surb[1].urb->transfer_buffer); + kfree(u->durb[0].urb->transfer_buffer); + kfree(u->durb[1].urb->transfer_buffer); + kfree(u->surb[0].urb->transfer_buffer); + kfree(u->surb[1].urb->transfer_buffer); u->durb[0].urb->transfer_buffer = u->durb[1].urb->transfer_buffer = u->surb[0].urb->transfer_buffer = u->surb[1].urb->transfer_buffer = NULL; } @@ -1009,21 +1005,17 @@ static int usbin_start(struct usb_audiodev *as) u->phase = 0; maxsze = (u->freqmax + 0x3fff) >> (14 - AFMT_BYTESSHIFT(u->format)); bufsz = DESCFRAMES * maxsze; - if (u->durb[0].urb->transfer_buffer) - kfree(u->durb[0].urb->transfer_buffer); + kfree(u->durb[0].urb->transfer_buffer); u->durb[0].urb->transfer_buffer = kmalloc(bufsz, GFP_KERNEL); u->durb[0].urb->transfer_buffer_length = bufsz; - if (u->durb[1].urb->transfer_buffer) - kfree(u->durb[1].urb->transfer_buffer); + kfree(u->durb[1].urb->transfer_buffer); u->durb[1].urb->transfer_buffer = kmalloc(bufsz, GFP_KERNEL); u->durb[1].urb->transfer_buffer_length = bufsz; if (u->syncpipe) { - if (u->surb[0].urb->transfer_buffer) - kfree(u->surb[0].urb->transfer_buffer); + kfree(u->surb[0].urb->transfer_buffer); u->surb[0].urb->transfer_buffer = kmalloc(3*SYNCFRAMES, GFP_KERNEL); u->surb[0].urb->transfer_buffer_length = 3*SYNCFRAMES; - if (u->surb[1].urb->transfer_buffer) - kfree(u->surb[1].urb->transfer_buffer); + kfree(u->surb[1].urb->transfer_buffer); u->surb[1].urb->transfer_buffer = kmalloc(3*SYNCFRAMES, GFP_KERNEL); u->surb[1].urb->transfer_buffer_length = 3*SYNCFRAMES; } @@ -1128,14 +1120,10 @@ static void usbout_stop(struct usb_audiodev *as) } } set_current_state(TASK_RUNNING); - if (u->durb[0].urb->transfer_buffer) - kfree(u->durb[0].urb->transfer_buffer); - if (u->durb[1].urb->transfer_buffer) - kfree(u->durb[1].urb->transfer_buffer); - if (u->surb[0].urb->transfer_buffer) - kfree(u->surb[0].urb->transfer_buffer); - if (u->surb[1].urb->transfer_buffer) - kfree(u->surb[1].urb->transfer_buffer); + kfree(u->durb[0].urb->transfer_buffer); + kfree(u->durb[1].urb->transfer_buffer); + kfree(u->surb[0].urb->transfer_buffer); + kfree(u->surb[1].urb->transfer_buffer); u->durb[0].urb->transfer_buffer = u->durb[1].urb->transfer_buffer = u->surb[0].urb->transfer_buffer = u->surb[1].urb->transfer_buffer = NULL; } @@ -1376,21 +1364,17 @@ static int usbout_start(struct usb_audiodev *as) u->phase = 0; maxsze = (u->freqmax + 0x3fff) >> (14 - AFMT_BYTESSHIFT(u->format)); bufsz = DESCFRAMES * maxsze; - if (u->durb[0].urb->transfer_buffer) - kfree(u->durb[0].urb->transfer_buffer); + kfree(u->durb[0].urb->transfer_buffer); u->durb[0].urb->transfer_buffer = kmalloc(bufsz, GFP_KERNEL); u->durb[0].urb->transfer_buffer_length = bufsz; - if (u->durb[1].urb->transfer_buffer) - kfree(u->durb[1].urb->transfer_buffer); + kfree(u->durb[1].urb->transfer_buffer); u->durb[1].urb->transfer_buffer = kmalloc(bufsz, GFP_KERNEL); u->durb[1].urb->transfer_buffer_length = bufsz; if (u->syncpipe) { - if (u->surb[0].urb->transfer_buffer) - kfree(u->surb[0].urb->transfer_buffer); + kfree(u->surb[0].urb->transfer_buffer); u->surb[0].urb->transfer_buffer = kmalloc(3*SYNCFRAMES, GFP_KERNEL); u->surb[0].urb->transfer_buffer_length = 3*SYNCFRAMES; - if (u->surb[1].urb->transfer_buffer) - kfree(u->surb[1].urb->transfer_buffer); + kfree(u->surb[1].urb->transfer_buffer); u->surb[1].urb->transfer_buffer = kmalloc(3*SYNCFRAMES, GFP_KERNEL); u->surb[1].urb->transfer_buffer_length = 3*SYNCFRAMES; } diff --git a/drivers/usb/class/bluetty.c b/drivers/usb/class/bluetty.c index 6bac65e0ade..524023327c4 100644 --- a/drivers/usb/class/bluetty.c +++ b/drivers/usb/class/bluetty.c @@ -309,7 +309,7 @@ static int bluetooth_ctrl_msg (struct usb_bluetooth *bluetooth, int request, int } } if (urb->transfer_buffer_length < len) { - kfree (urb->transfer_buffer); + kfree(urb->transfer_buffer); urb->transfer_buffer = kmalloc (len, GFP_KERNEL); if (urb->transfer_buffer == NULL) { err ("%s - out of memory", __FUNCTION__); @@ -535,7 +535,7 @@ static int bluetooth_write (struct tty_struct * tty, const unsigned char *buf, i } exit: - kfree (temp_buffer); + kfree(temp_buffer); return retval; } diff --git a/drivers/usb/core/config.c b/drivers/usb/core/config.c index 0b092bdf98f..99595e07b65 100644 --- a/drivers/usb/core/config.c +++ b/drivers/usb/core/config.c @@ -10,7 +10,8 @@ #include <linux/slab.h> #include <linux/device.h> #include <asm/byteorder.h> - +#include "usb.h" +#include "hcd.h" #define USB_MAXALTSETTING 128 /* Hard limit */ #define USB_MAXENDPOINTS 30 /* Hard limit */ diff --git a/drivers/usb/core/devices.c b/drivers/usb/core/devices.c index 8b61bcd742c..ef0b35731ff 100644 --- a/drivers/usb/core/devices.c +++ b/drivers/usb/core/devices.c @@ -59,6 +59,7 @@ #include <linux/usbdevice_fs.h> #include <asm/uaccess.h> +#include "usb.h" #include "hcd.h" #define MAX_TOPO_LEVEL 6 @@ -636,11 +637,8 @@ static int usb_device_open(struct inode *inode, struct file *file) static int usb_device_release(struct inode *inode, struct file *file) { - if (file->private_data) { - kfree(file->private_data); - file->private_data = NULL; - } - + kfree(file->private_data); + file->private_data = NULL; return 0; } diff --git a/drivers/usb/core/devio.c b/drivers/usb/core/devio.c index a047bc39298..6bfab4bcaa9 100644 --- a/drivers/usb/core/devio.c +++ b/drivers/usb/core/devio.c @@ -213,12 +213,10 @@ static struct async *alloc_async(unsigned int numisoframes) static void free_async(struct async *as) { - if (as->urb->transfer_buffer) - kfree(as->urb->transfer_buffer); - if (as->urb->setup_packet) - kfree(as->urb->setup_packet); + kfree(as->urb->transfer_buffer); + kfree(as->urb->setup_packet); usb_free_urb(as->urb); - kfree(as); + kfree(as); } static inline void async_newpending(struct async *as) @@ -938,17 +936,13 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb, return -EINVAL; } if (!(as = alloc_async(uurb->number_of_packets))) { - if (isopkt) - kfree(isopkt); - if (dr) - kfree(dr); + kfree(isopkt); + kfree(dr); return -ENOMEM; } if (!(as->urb->transfer_buffer = kmalloc(uurb->buffer_length, GFP_KERNEL))) { - if (isopkt) - kfree(isopkt); - if (dr) - kfree(dr); + kfree(isopkt); + kfree(dr); free_async(as); return -ENOMEM; } @@ -967,8 +961,7 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb, as->urb->iso_frame_desc[u].length = isopkt[u].length; totlen += isopkt[u].length; } - if (isopkt) - kfree(isopkt); + kfree(isopkt); as->ps = ps; as->userurb = arg; if (uurb->endpoint & USB_DIR_IN) @@ -1032,15 +1025,15 @@ static int processcompl(struct async *as, void __user * __user *arg) if (put_user(urb->error_count, &userurb->error_count)) return -EFAULT; - if (!(usb_pipeisoc(urb->pipe))) - return 0; - for (i = 0; i < urb->number_of_packets; i++) { - if (put_user(urb->iso_frame_desc[i].actual_length, - &userurb->iso_frame_desc[i].actual_length)) - return -EFAULT; - if (put_user(urb->iso_frame_desc[i].status, - &userurb->iso_frame_desc[i].status)) - return -EFAULT; + if (usb_pipeisoc(urb->pipe)) { + for (i = 0; i < urb->number_of_packets; i++) { + if (put_user(urb->iso_frame_desc[i].actual_length, + &userurb->iso_frame_desc[i].actual_length)) + return -EFAULT; + if (put_user(urb->iso_frame_desc[i].status, + &userurb->iso_frame_desc[i].status)) + return -EFAULT; + } } free_async(as); @@ -1126,7 +1119,7 @@ static int proc_submiturb_compat(struct dev_state *ps, void __user *arg) if (get_urb32(&uurb,(struct usbdevfs_urb32 *)arg)) return -EFAULT; - return proc_do_submiturb(ps, &uurb, ((struct usbdevfs_urb __user *)arg)->iso_frame_desc, arg); + return proc_do_submiturb(ps, &uurb, ((struct usbdevfs_urb32 __user *)arg)->iso_frame_desc, arg); } static int processcompl_compat(struct async *as, void __user * __user *arg) @@ -1146,15 +1139,15 @@ static int processcompl_compat(struct async *as, void __user * __user *arg) if (put_user(urb->error_count, &userurb->error_count)) return -EFAULT; - if (!(usb_pipeisoc(urb->pipe))) - return 0; - for (i = 0; i < urb->number_of_packets; i++) { - if (put_user(urb->iso_frame_desc[i].actual_length, - &userurb->iso_frame_desc[i].actual_length)) - return -EFAULT; - if (put_user(urb->iso_frame_desc[i].status, - &userurb->iso_frame_desc[i].status)) - return -EFAULT; + if (usb_pipeisoc(urb->pipe)) { + for (i = 0; i < urb->number_of_packets; i++) { + if (put_user(urb->iso_frame_desc[i].actual_length, + &userurb->iso_frame_desc[i].actual_length)) + return -EFAULT; + if (put_user(urb->iso_frame_desc[i].status, + &userurb->iso_frame_desc[i].status)) + return -EFAULT; + } } free_async(as); @@ -1177,10 +1170,8 @@ static int proc_reapurbnonblock_compat(struct dev_state *ps, void __user *arg) { struct async *as; - printk("reapurbnblock\n"); if (!(as = async_getcompleted(ps))) return -EAGAIN; - printk("reap got as %p\n", as); return processcompl_compat(as, (void __user * __user *)arg); } @@ -1239,7 +1230,7 @@ static int proc_ioctl (struct dev_state *ps, void __user *arg) return -ENOMEM; if ((_IOC_DIR(ctrl.ioctl_code) & _IOC_WRITE)) { if (copy_from_user (buf, ctrl.data, size)) { - kfree (buf); + kfree(buf); return -EFAULT; } } else { @@ -1248,8 +1239,7 @@ static int proc_ioctl (struct dev_state *ps, void __user *arg) } if (!connected(ps->dev)) { - if (buf) - kfree(buf); + kfree(buf); return -ENODEV; } @@ -1311,8 +1301,8 @@ static int proc_ioctl (struct dev_state *ps, void __user *arg) && size > 0 && copy_to_user (ctrl.data, buf, size) != 0) retval = -EFAULT; - if (buf != NULL) - kfree (buf); + + kfree(buf); return retval; } diff --git a/drivers/usb/core/file.c b/drivers/usb/core/file.c index 80ce9644d0e..38ed2220c9f 100644 --- a/drivers/usb/core/file.c +++ b/drivers/usb/core/file.c @@ -28,6 +28,8 @@ #endif #include <linux/usb.h> +#include "usb.h" + #define MAX_USB_MINORS 256 static struct file_operations *usb_minors[MAX_USB_MINORS]; static DEFINE_SPINLOCK(minor_lock); diff --git a/drivers/usb/core/hcd-pci.c b/drivers/usb/core/hcd-pci.c index b9a3dae0703..71b4a8d6631 100644 --- a/drivers/usb/core/hcd-pci.c +++ b/drivers/usb/core/hcd-pci.c @@ -33,7 +33,7 @@ #include "hcd.h" -/* PCI-based HCs are normal, but custom bus glue should be ok */ +/* PCI-based HCs are common, but plenty of non-PCI HCs are used too */ /*-------------------------------------------------------------------------*/ @@ -67,8 +67,8 @@ int usb_hcd_pci_probe (struct pci_dev *dev, const struct pci_device_id *id) if (pci_enable_device (dev) < 0) return -ENODEV; - dev->current_state = 0; - dev->dev.power.power_state = 0; + dev->current_state = PCI_D0; + dev->dev.power.power_state = PMSG_ON; if (!dev->irq) { dev_err (&dev->dev, @@ -186,26 +186,14 @@ EXPORT_SYMBOL (usb_hcd_pci_remove); #ifdef CONFIG_PM -static char __attribute_used__ *pci_state(u32 state) -{ - switch (state) { - case 0: return "D0"; - case 1: return "D1"; - case 2: return "D2"; - case 3: return "D3hot"; - case 4: return "D3cold"; - } - return NULL; -} - /** * usb_hcd_pci_suspend - power management suspend of a PCI-based HCD * @dev: USB Host Controller being suspended - * @state: state that the controller is going into + * @message: semantics in flux * * Store this function in the HCD's struct pci_driver as suspend(). */ -int usb_hcd_pci_suspend (struct pci_dev *dev, u32 state) +int usb_hcd_pci_suspend (struct pci_dev *dev, pm_message_t message) { struct usb_hcd *hcd; int retval = 0; @@ -213,13 +201,23 @@ int usb_hcd_pci_suspend (struct pci_dev *dev, u32 state) hcd = pci_get_drvdata(dev); + /* FIXME until the generic PM interfaces change a lot more, this + * can't use PCI D1 and D2 states. For example, the confusion + * between messages and states will need to vanish, and messages + * will need to provide a target system state again. + * + * It'll be important to learn characteristics of the target state, + * especially on embedded hardware where the HCD will often be in + * charge of an external VBUS power supply and one or more clocks. + * Some target system states will leave them active; others won't. + * (With PCI, that's often handled by platform BIOS code.) + */ + /* even when the PCI layer rejects some of the PCI calls * below, HCs can try global suspend and reduce DMA traffic. * PM-sensitive HCDs may already have done this. */ has_pci_pm = pci_find_capability(dev, PCI_CAP_ID_PM); - if (state > 4) - state = 4; switch (hcd->state) { @@ -228,7 +226,7 @@ int usb_hcd_pci_suspend (struct pci_dev *dev, u32 state) */ case HC_STATE_RUNNING: hcd->state = HC_STATE_QUIESCING; - retval = hcd->driver->suspend (hcd, state); + retval = hcd->driver->suspend (hcd, message); if (retval) { dev_dbg (hcd->self.controller, "suspend fail, retval %d\n", @@ -246,14 +244,11 @@ int usb_hcd_pci_suspend (struct pci_dev *dev, u32 state) * have been called, otherwise root hub timers still run ... */ case HC_STATE_SUSPENDED: - if (state <= dev->current_state) - break; - - /* no DMA or IRQs except in D0 */ - if (!dev->current_state) { + /* no DMA or IRQs except when HC is active */ + if (dev->current_state == PCI_D0) { + free_irq (hcd->irq, hcd); pci_save_state (dev); pci_disable_device (dev); - free_irq (hcd->irq, hcd); } if (!has_pci_pm) { @@ -261,25 +256,19 @@ int usb_hcd_pci_suspend (struct pci_dev *dev, u32 state) break; } - /* POLICY: ignore D1/D2/D3hot differences; - * we know D3hot will always work. + /* NOTE: dev->current_state becomes nonzero only here, and + * only for devices that support PCI PM. Also, exiting + * PCI_D3 (but not PCI_D1 or PCI_D2) is allowed to reset + * some device state (e.g. as part of clock reinit). */ - retval = pci_set_power_state (dev, state); - if (retval < 0 && state < 3) { - retval = pci_set_power_state (dev, 3); - if (retval == 0) - state = 3; - } + retval = pci_set_power_state (dev, PCI_D3hot); if (retval == 0) { - dev_dbg (hcd->self.controller, "--> PCI %s\n", - pci_state(dev->current_state)); -#ifdef CONFIG_USB_SUSPEND - pci_enable_wake (dev, state, hcd->remote_wakeup); - pci_enable_wake (dev, 4, hcd->remote_wakeup); -#endif + dev_dbg (hcd->self.controller, "--> PCI D3\n"); + pci_enable_wake (dev, PCI_D3hot, hcd->remote_wakeup); + pci_enable_wake (dev, PCI_D3cold, hcd->remote_wakeup); } else if (retval < 0) { - dev_dbg (&dev->dev, "PCI %s suspend fail, %d\n", - pci_state(state), retval); + dev_dbg (&dev->dev, "PCI D3 suspend fail, %d\n", + retval); (void) usb_hcd_pci_resume (dev); break; } @@ -287,13 +276,14 @@ int usb_hcd_pci_suspend (struct pci_dev *dev, u32 state) default: dev_dbg (hcd->self.controller, "hcd state %d; not suspended\n", hcd->state); + WARN_ON(1); retval = -EINVAL; break; } /* update power_state **ONLY** to make sysfs happier */ if (retval == 0) - dev->dev.power.power_state = state; + dev->dev.power.power_state = message; return retval; } EXPORT_SYMBOL (usb_hcd_pci_suspend); @@ -308,7 +298,6 @@ int usb_hcd_pci_resume (struct pci_dev *dev) { struct usb_hcd *hcd; int retval; - int has_pci_pm; hcd = pci_get_drvdata(dev); if (hcd->state != HC_STATE_SUSPENDED) { @@ -316,31 +305,73 @@ int usb_hcd_pci_resume (struct pci_dev *dev) "can't resume, not suspended!\n"); return 0; } - has_pci_pm = pci_find_capability(dev, PCI_CAP_ID_PM); - /* D3cold resume isn't usually reported this way... */ - dev_dbg(hcd->self.controller, "resume from PCI %s%s\n", - pci_state(dev->current_state), - has_pci_pm ? "" : " (legacy)"); + /* NOTE: chip docs cover clean "real suspend" cases (what Linux + * calls "standby", "suspend to RAM", and so on). There are also + * dirty cases when swsusp fakes a suspend in "shutdown" mode. + */ + if (dev->current_state != PCI_D0) { +#ifdef DEBUG + int pci_pm; + u16 pmcr; + + pci_pm = pci_find_capability(dev, PCI_CAP_ID_PM); + pci_read_config_word(dev, pci_pm + PCI_PM_CTRL, &pmcr); + pmcr &= PCI_PM_CTRL_STATE_MASK; + if (pmcr) { + /* Clean case: power to USB and to HC registers was + * maintained; remote wakeup is easy. + */ + dev_dbg(hcd->self.controller, "resume from PCI D%d\n", + pmcr); + } else { + /* Clean: HC lost Vcc power, D0 uninitialized + * + Vaux may have preserved port and transceiver + * state ... for remote wakeup from D3cold + * + or not; HCD must reinit + re-enumerate + * + * Dirty: D0 semi-initialized cases with swsusp + * + after BIOS init + * + after Linux init (HCD statically linked) + */ + dev_dbg(hcd->self.controller, + "PCI D0, from previous PCI D%d\n", + dev->current_state); + } +#endif + pci_enable_wake (dev, dev->current_state, 0); + pci_enable_wake (dev, PCI_D3cold, 0); + } else { + /* Same basic cases: clean (powered/not), dirty */ + dev_dbg(hcd->self.controller, "PCI legacy resume\n"); + } + + /* NOTE: the PCI API itself is asymmetric here. We don't need to + * pci_set_power_state(PCI_D0) since that's part of re-enabling; + * but that won't re-enable bus mastering. Yet pci_disable_device() + * explicitly disables bus mastering... + */ + retval = pci_enable_device (dev); + if (retval < 0) { + dev_err (hcd->self.controller, + "can't re-enable after resume, %d!\n", retval); + return retval; + } + pci_set_master (dev); + pci_restore_state (dev); + + dev->dev.power.power_state = PMSG_ON; hcd->state = HC_STATE_RESUMING; - - if (has_pci_pm) - pci_set_power_state (dev, 0); - dev->dev.power.power_state = 0; + hcd->saw_irq = 0; retval = request_irq (dev->irq, usb_hcd_irq, SA_SHIRQ, - hcd->driver->description, hcd); + hcd->irq_descr, hcd); if (retval < 0) { dev_err (hcd->self.controller, "can't restore IRQ after resume!\n"); + usb_hc_died (hcd); return retval; } - hcd->saw_irq = 0; - pci_restore_state (dev); -#ifdef CONFIG_USB_SUSPEND - pci_enable_wake (dev, dev->current_state, 0); - pci_enable_wake (dev, 4, 0); -#endif retval = hcd->driver->resume (hcd); if (!HC_IS_RUNNING (hcd->state)) { diff --git a/drivers/usb/core/hcd.h b/drivers/usb/core/hcd.h index 6c625b35fa0..f67cf1e634f 100644 --- a/drivers/usb/core/hcd.h +++ b/drivers/usb/core/hcd.h @@ -177,7 +177,7 @@ struct hc_driver { * a whole, not just the root hub; they're for bus glue. */ /* called after all devices were suspended */ - int (*suspend) (struct usb_hcd *hcd, u32 state); + int (*suspend) (struct usb_hcd *hcd, pm_message_t message); /* called before any devices get resumed */ int (*resume) (struct usb_hcd *hcd); @@ -226,7 +226,7 @@ extern int usb_hcd_pci_probe (struct pci_dev *dev, extern void usb_hcd_pci_remove (struct pci_dev *dev); #ifdef CONFIG_PM -extern int usb_hcd_pci_suspend (struct pci_dev *dev, u32 state); +extern int usb_hcd_pci_suspend (struct pci_dev *dev, pm_message_t state); extern int usb_hcd_pci_resume (struct pci_dev *dev); #endif /* CONFIG_PM */ diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c index fa0dc4f6de4..d2d648ee864 100644 --- a/drivers/usb/core/hub.c +++ b/drivers/usb/core/hub.c @@ -381,7 +381,7 @@ static void hub_tt_kevent (void *arg) dev_err (&hdev->dev, "clear tt %d (%04x) error %d\n", clear->tt, clear->devinfo, status); - kfree (clear); + kfree(clear); } spin_unlock_irqrestore (&hub->tt.lock, flags); } @@ -728,15 +728,11 @@ static void hub_disconnect(struct usb_interface *intf) list_del_init(&hub->event_list); spin_unlock_irq(&hub_event_lock); - if (hub->descriptor) { - kfree(hub->descriptor); - hub->descriptor = NULL; - } + kfree(hub->descriptor); + hub->descriptor = NULL; - if (hub->status) { - kfree(hub->status); - hub->status = NULL; - } + kfree(hub->status); + hub->status = NULL; if (hub->buffer) { usb_buffer_free(hdev, sizeof(*hub->buffer), hub->buffer, @@ -1456,7 +1452,7 @@ static void hub_port_logical_disconnect(struct usb_hub *hub, int port1) /* FIXME let caller ask to power down the port: * - some devices won't enumerate without a VBUS power cycle * - SRP saves power that way - * - usb_suspend_device(dev,PM_SUSPEND_DISK) + * - usb_suspend_device(dev, PMSG_SUSPEND) * That's easy if this hub can switch power per-port, and * khubd reactivates the port later (timer, SRP, etc). * Powerdown must be optional, because of reset/DFU. @@ -1531,7 +1527,7 @@ static int hub_port_suspend(struct usb_hub *hub, int port1, /* * Devices on USB hub ports have only one "suspend" state, corresponding - * to ACPI D2 (PM_SUSPEND_MEM), "may cause the device to lose some context". + * to ACPI D2, "may cause the device to lose some context". * State transitions include: * * - suspend, resume ... when the VBUS power link stays live @@ -1731,7 +1727,7 @@ static int finish_port_resume(struct usb_device *udev) struct usb_driver *driver; intf = udev->actconfig->interface[i]; - if (intf->dev.power.power_state == PM_SUSPEND_ON) + if (intf->dev.power.power_state == PMSG_SUSPEND) continue; if (!intf->dev.driver) { /* FIXME maybe force to alt 0 */ @@ -1745,7 +1741,7 @@ static int finish_port_resume(struct usb_device *udev) /* can we do better than just logging errors? */ status = driver->resume(intf); - if (intf->dev.power.power_state != PM_SUSPEND_ON + if (intf->dev.power.power_state != PMSG_ON || status) dev_dbg(&intf->dev, "resume fail, state %d code %d\n", @@ -2354,7 +2350,7 @@ check_highspeed (struct usb_hub *hub, struct usb_device *udev, int port1) schedule_work (&hub->leds); } } - kfree (qual); + kfree(qual); } static unsigned diff --git a/drivers/usb/core/inode.c b/drivers/usb/core/inode.c index d913407bcdc..f9f9561c6ba 100644 --- a/drivers/usb/core/inode.c +++ b/drivers/usb/core/inode.c @@ -41,6 +41,7 @@ #include <linux/parser.h> #include <asm/byteorder.h> #include "usb.h" +#include "hcd.h" static struct super_operations usbfs_ops; static struct file_operations default_file_operations; diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c index 40bdb38e7bc..e12c5be1e0a 100644 --- a/drivers/usb/core/message.c +++ b/drivers/usb/core/message.c @@ -1133,29 +1133,10 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate) /* prevent submissions using previous endpoint settings */ usb_disable_interface(dev, iface); - /* 9.1.1.5 says: - * - * Configuring a device or changing an alternate setting - * causes all of the status and configuration values - * associated with endpoints in the affected interfaces to - * be set to their default values. This includes setting - * the data toggle of any endpoint using data toggles to - * the value DATA0. - * - * Some devices take this too literally and don't reset the data - * toggles if the new altsetting is the same as the old one (the - * command isn't "changing" an alternate setting). We will manually - * reset the toggles when the new and old altsettings are the same. - * Most devices won't need this, but fortunately it doesn't happen - * often. - */ - if (iface->cur_altsetting == alt) - manual = 1; iface->cur_altsetting = alt; /* If the interface only has one altsetting and the device didn't - * accept the request (or whenever the old altsetting is the same - * as the new one), we attempt to carry out the equivalent action + * accept the request, we attempt to carry out the equivalent action * by manually clearing the HALT feature for each endpoint in the * new altsetting. */ @@ -1202,7 +1183,9 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate) * * Because this affects multiple interfaces, avoid using this with composite * (multi-interface) devices. Instead, the driver for each interface may - * use usb_set_interface() on the interfaces it claims. Resetting the whole + * use usb_set_interface() on the interfaces it claims. Be careful though; + * some devices don't support the SET_INTERFACE request, and others won't + * reset all the interface state (notably data toggles). Resetting the whole * configuration would affect other drivers' interfaces. * * The caller must own the device lock. diff --git a/drivers/usb/core/urb.c b/drivers/usb/core/urb.c index dc838f81742..16972159a57 100644 --- a/drivers/usb/core/urb.c +++ b/drivers/usb/core/urb.c @@ -420,12 +420,16 @@ int usb_submit_urb(struct urb *urb, int mem_flags) * * Host Controller Drivers (HCDs) place all the URBs for a particular * endpoint in a queue. Normally the queue advances as the controller - * hardware processes each request. But when an URB terminates with any - * fault (such as an error, or being unlinked) its queue stops, at least - * until that URB's completion routine returns. It is guaranteed that - * the queue will not restart until all its unlinked URBs have been fully - * retired, with their completion routines run, even if that's not until - * some time after the original completion handler returns. + * hardware processes each request. But when an URB terminates with an + * error its queue stops, at least until that URB's completion routine + * returns. It is guaranteed that the queue will not restart until all + * its unlinked URBs have been fully retired, with their completion + * routines run, even if that's not until some time after the original + * completion handler returns. Normally the same behavior and guarantees + * apply when an URB terminates because it was unlinked; however if an + * URB is unlinked before the hardware has started to execute it, then + * its queue is not guaranteed to stop until all the preceding URBs have + * completed. * * This means that USB device drivers can safely build deep queues for * large or complex transfers, and clean them up reliably after any sort diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c index f0534ee0649..c231b4bef31 100644 --- a/drivers/usb/core/usb.c +++ b/drivers/usb/core/usb.c @@ -50,13 +50,6 @@ #include "hcd.h" #include "usb.h" -extern int usb_hub_init(void); -extern void usb_hub_cleanup(void); -extern int usb_major_init(void); -extern void usb_major_cleanup(void); -extern int usb_host_init(void); -extern void usb_host_cleanup(void); - const char *usbcore_name = "usbcore"; @@ -1382,13 +1375,13 @@ void usb_buffer_unmap_sg (struct usb_device *dev, unsigned pipe, usb_pipein (pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE); } -static int usb_generic_suspend(struct device *dev, u32 state) +static int usb_generic_suspend(struct device *dev, pm_message_t message) { struct usb_interface *intf; struct usb_driver *driver; if (dev->driver == &usb_generic_driver) - return usb_suspend_device (to_usb_device(dev), state); + return usb_suspend_device (to_usb_device(dev), message); if ((dev->driver == NULL) || (dev->driver_data == &usb_generic_driver_data)) @@ -1402,7 +1395,7 @@ static int usb_generic_suspend(struct device *dev, u32 state) return 0; if (driver->suspend) - return driver->suspend(intf, state); + return driver->suspend(intf, message); return 0; } diff --git a/drivers/usb/core/usb.h b/drivers/usb/core/usb.h index 4c33eee5200..2c690f6d4c1 100644 --- a/drivers/usb/core/usb.h +++ b/drivers/usb/core/usb.h @@ -21,6 +21,13 @@ extern void usb_unlock_all_devices(void); extern void usb_kick_khubd(struct usb_device *dev); extern void usb_resume_root_hub(struct usb_device *dev); +extern int usb_hub_init(void); +extern void usb_hub_cleanup(void); +extern int usb_major_init(void); +extern void usb_major_cleanup(void); +extern int usb_host_init(void); +extern void usb_host_cleanup(void); + /* for labeling diagnostics */ extern const char *usbcore_name; @@ -30,6 +37,7 @@ extern struct file_operations usbfs_devices_fops; extern struct file_operations usbfs_device_file_operations; extern void usbfs_conn_disc_event(void); + struct dev_state { struct list_head list; /* state list */ struct usb_device *dev; diff --git a/drivers/usb/gadget/ether.c b/drivers/usb/gadget/ether.c index cff9fb0b73c..3993156c2e8 100644 --- a/drivers/usb/gadget/ether.c +++ b/drivers/usb/gadget/ether.c @@ -100,6 +100,8 @@ static const char driver_desc [] = DRIVER_DESC; /* CDC and RNDIS support the same host-chosen outgoing packet filters. */ #define DEFAULT_FILTER (USB_CDC_PACKET_TYPE_BROADCAST \ + |USB_CDC_PACKET_TYPE_ALL_MULTICAST \ + |USB_CDC_PACKET_TYPE_PROMISCUOUS \ |USB_CDC_PACKET_TYPE_DIRECTED) @@ -322,12 +324,18 @@ module_param (qmult, uint, S_IRUGO|S_IWUSR); /* also defer IRQs on highspeed TX */ #define TX_DELAY qmult -#define BITRATE(g) (((g)->speed == USB_SPEED_HIGH) ? HS_BPS : FS_BPS) +static inline int BITRATE(struct usb_gadget *g) +{ + return (g->speed == USB_SPEED_HIGH) ? HS_BPS : FS_BPS; +} #else /* full speed (low speed doesn't do bulk) */ #define qlen(gadget) DEFAULT_QLEN -#define BITRATE(g) FS_BPS +static inline int BITRATE(struct usb_gadget *g) +{ + return FS_BPS; +} #endif @@ -1167,7 +1175,7 @@ eth_set_config (struct eth_dev *dev, unsigned number, int gfp_flags) eth_reset_config (dev); /* default: pass all packets, no multicast filtering */ - dev->cdc_filter = 0x000f; + dev->cdc_filter = DEFAULT_FILTER; switch (number) { case DEV_CONFIG_VALUE: @@ -1343,9 +1351,9 @@ eth_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl) struct eth_dev *dev = get_gadget_data (gadget); struct usb_request *req = dev->req; int value = -EOPNOTSUPP; - u16 wIndex = ctrl->wIndex; - u16 wValue = ctrl->wValue; - u16 wLength = ctrl->wLength; + u16 wIndex = (__force u16) ctrl->wIndex; + u16 wValue = (__force u16) ctrl->wValue; + u16 wLength = (__force u16) ctrl->wLength; /* descriptors just go into the pre-allocated ep0 buffer, * while config change events may enable network traffic. @@ -1693,7 +1701,7 @@ rx_submit (struct eth_dev *dev, struct usb_request *req, int gfp_flags) /* Some platforms perform better when IP packets are aligned, * but on at least one, checksumming fails otherwise. Note: - * this doesn't account for variable-sized RNDIS headers. + * RNDIS headers involve variable numbers of LE32 values. */ skb_reserve(skb, NET_IP_ALIGN); @@ -1730,9 +1738,11 @@ static void rx_complete (struct usb_ep *ep, struct usb_request *req) #ifdef CONFIG_USB_ETH_RNDIS /* we know MaxPacketsPerTransfer == 1 here */ if (dev->rndis) - rndis_rm_hdr (req->buf, &(skb->len)); + status = rndis_rm_hdr (skb); #endif - if (ETH_HLEN > skb->len || skb->len > ETH_FRAME_LEN) { + if (status < 0 + || ETH_HLEN > skb->len + || skb->len > ETH_FRAME_LEN) { dev->stats.rx_errors++; dev->stats.rx_length_errors++; DEBUG (dev, "rx length %d\n", skb->len); @@ -2047,38 +2057,20 @@ rndis_control_ack_complete (struct usb_ep *ep, struct usb_request *req) DEBUG ((struct eth_dev *) ep->driver_data, "rndis control ack complete --> %d, %d/%d\n", req->status, req->actual, req->length); - - usb_ep_free_buffer(ep, req->buf, req->dma, 8); - usb_ep_free_request(ep, req); } static int rndis_control_ack (struct net_device *net) { struct eth_dev *dev = netdev_priv(net); u32 length; - struct usb_request *resp; + struct usb_request *resp = dev->stat_req; /* in case RNDIS calls this after disconnect */ - if (!dev->status_ep) { + if (!dev->status) { DEBUG (dev, "status ENODEV\n"); return -ENODEV; } - /* Allocate memory for notification ie. ACK */ - resp = usb_ep_alloc_request (dev->status_ep, GFP_ATOMIC); - if (!resp) { - DEBUG (dev, "status ENOMEM\n"); - return -ENOMEM; - } - - resp->buf = usb_ep_alloc_buffer (dev->status_ep, 8, - &resp->dma, GFP_ATOMIC); - if (!resp->buf) { - DEBUG (dev, "status buf ENOMEM\n"); - usb_ep_free_request (dev->status_ep, resp); - return -ENOMEM; - } - /* Send RNDIS RESPONSE_AVAILABLE notification; * USB_CDC_NOTIFY_RESPONSE_AVAILABLE should work too */ @@ -2113,7 +2105,7 @@ static void eth_start (struct eth_dev *dev, int gfp_flags) if (dev->rndis) { rndis_set_param_medium (dev->rndis_config, NDIS_MEDIUM_802_3, - BITRATE(dev->gadget)); + BITRATE(dev->gadget)/100); rndis_send_media_state (dev, 1); } #endif @@ -2307,8 +2299,8 @@ eth_bind (struct usb_gadget *gadget) device_desc.bcdDevice = __constant_cpu_to_le16 (0x0210); } else if (gadget_is_pxa27x(gadget)) { device_desc.bcdDevice = __constant_cpu_to_le16 (0x0211); - } else if (gadget_is_s3c2410(gadget)) { - device_desc.bcdDevice = __constant_cpu_to_le16 (0x0212); + } else if (gadget_is_s3c2410(gadget)) { + device_desc.bcdDevice = __constant_cpu_to_le16 (0x0212); } else if (gadget_is_at91(gadget)) { device_desc.bcdDevice = __constant_cpu_to_le16 (0x0213); } else { diff --git a/drivers/usb/gadget/omap_udc.c b/drivers/usb/gadget/omap_udc.c index b66ea5a6ed7..98cbcbc16cc 100644 --- a/drivers/usb/gadget/omap_udc.c +++ b/drivers/usb/gadget/omap_udc.c @@ -2809,17 +2809,15 @@ static int __exit omap_udc_remove(struct device *dev) return 0; } -/* suspend/resume/wakeup from sysfs (echo > power/state) */ - -static int omap_udc_suspend(struct device *dev, u32 state, u32 level) +static int omap_udc_suspend(struct device *dev, pm_message_t state, u32 level) { if (level != 0) return 0; DBG("suspend, state %d\n", state); omap_pullup(&udc->gadget, 0); - udc->gadget.dev.power.power_state = 3; - udc->gadget.dev.parent->power.power_state = 3; + udc->gadget.dev.power.power_state = PMSG_SUSPEND; + udc->gadget.dev.parent->power.power_state = PMSG_SUSPEND; return 0; } @@ -2829,8 +2827,8 @@ static int omap_udc_resume(struct device *dev, u32 level) return 0; DBG("resume + wakeup/SRP\n"); - udc->gadget.dev.parent->power.power_state = 0; - udc->gadget.dev.power.power_state = 0; + udc->gadget.dev.parent->power.power_state = PMSG_ON; + udc->gadget.dev.power.power_state = PMSG_ON; omap_pullup(&udc->gadget, 1); /* maybe the host would enumerate us if we nudged it */ diff --git a/drivers/usb/gadget/rndis.c b/drivers/usb/gadget/rndis.c index 6c5197850ed..7457268d5f2 100644 --- a/drivers/usb/gadget/rndis.c +++ b/drivers/usb/gadget/rndis.c @@ -37,6 +37,7 @@ #include <asm/io.h> #include <asm/byteorder.h> #include <asm/system.h> +#include <asm/unaligned.h> #undef RNDIS_PM @@ -165,7 +166,7 @@ static int gen_ndis_query_resp (int configNr, u32 OID, rndis_resp_t *r) /* mandatory */ case OID_GEN_LINK_SPEED: - DEBUG("%s: OID_GEN_LINK_SPEED\n", __FUNCTION__); +// DEBUG("%s: OID_GEN_LINK_SPEED\n", __FUNCTION__); length = 4; if (rndis_per_dev_params [configNr].media_state == NDIS_MEDIA_STATE_DISCONNECTED) @@ -729,7 +730,7 @@ static int gen_ndis_set_resp (u8 configNr, u32 OID, u8 *buf, u32 buf_len, retval = 0; /* FIXME use these NDIS_PACKET_TYPE_* bitflags to - * filter packets in hard_start_xmit() + * set the cdc_filter; it's not RNDIS-specific * NDIS_PACKET_TYPE_x == USB_CDC_PACKET_TYPE_x for x in: * PROMISCUOUS, DIRECTED, * MULTICAST, ALL_MULTICAST, BROADCAST @@ -1194,10 +1195,10 @@ void rndis_add_hdr (struct sk_buff *skb) return; header = (void *) skb_push (skb, sizeof *header); memset (header, 0, sizeof *header); - header->MessageType = __constant_cpu_to_le32 (1); + header->MessageType = __constant_cpu_to_le32(REMOTE_NDIS_PACKET_MSG); header->MessageLength = cpu_to_le32(skb->len); header->DataOffset = __constant_cpu_to_le32 (36); - header->OOBDataOffset = cpu_to_le32(skb->len - 44); + header->DataLength = cpu_to_le32(skb->len - sizeof *header); } void rndis_free_response (int configNr, u8 *buf) @@ -1253,26 +1254,23 @@ static rndis_resp_t *rndis_add_response (int configNr, u32 length) return r; } -int rndis_rm_hdr (u8 *buf, u32 *length) +int rndis_rm_hdr(struct sk_buff *skb) { - u32 i, messageLen, dataOffset; - __le32 *tmp; - - tmp = (__le32 *) buf; + /* tmp points to a struct rndis_packet_msg_type */ + __le32 *tmp = (void *) skb->data; - if (!buf || !length) return -1; - if (le32_to_cpup(tmp++) != 1) return -1; - - messageLen = le32_to_cpup(tmp++); - dataOffset = le32_to_cpup(tmp++) + 8; + /* MessageType, MessageLength */ + if (__constant_cpu_to_le32(REMOTE_NDIS_PACKET_MSG) + != get_unaligned(tmp++)) + return -EINVAL; + tmp++; + + /* DataOffset, DataLength */ + if (!skb_pull(skb, le32_to_cpu(get_unaligned(tmp++)) + + 8 /* offset of DataOffset */)) + return -EOVERFLOW; + skb_trim(skb, le32_to_cpu(get_unaligned(tmp++))); - if (messageLen < dataOffset || messageLen > *length) return -1; - - for (i = dataOffset; i < messageLen; i++) - buf [i - dataOffset] = buf [i]; - - *length = messageLen - dataOffset; - return 0; } diff --git a/drivers/usb/gadget/rndis.h b/drivers/usb/gadget/rndis.h index 822501852c5..2b5b55df3cf 100644 --- a/drivers/usb/gadget/rndis.h +++ b/drivers/usb/gadget/rndis.h @@ -38,6 +38,7 @@ */ /* Message Set for Connectionless (802.3) Devices */ +#define REMOTE_NDIS_PACKET_MSG 0x00000001U #define REMOTE_NDIS_INITIALIZE_MSG 0x00000002U /* Initialize device */ #define REMOTE_NDIS_HALT_MSG 0x00000003U #define REMOTE_NDIS_QUERY_MSG 0x00000004U @@ -333,7 +334,7 @@ int rndis_set_param_vendor (u8 configNr, u32 vendorID, const char *vendorDescr); int rndis_set_param_medium (u8 configNr, u32 medium, u32 speed); void rndis_add_hdr (struct sk_buff *skb); -int rndis_rm_hdr (u8 *buf, u32 *length); +int rndis_rm_hdr (struct sk_buff *skb); u8 *rndis_get_next_response (int configNr, u32 *length); void rndis_free_response (int configNr, u8 *buf); diff --git a/drivers/usb/gadget/serial.c b/drivers/usb/gadget/serial.c index 2af3f785d5a..f1762ed6db6 100644 --- a/drivers/usb/gadget/serial.c +++ b/drivers/usb/gadget/serial.c @@ -2312,9 +2312,8 @@ static struct gs_buf *gs_buf_alloc(unsigned int size, int kmalloc_flags) */ void gs_buf_free(struct gs_buf *gb) { - if (gb != NULL) { - if (gb->buf_buf != NULL) - kfree(gb->buf_buf); + if (gb) { + kfree(gb->buf_buf); kfree(gb); } } diff --git a/drivers/usb/host/ehci-dbg.c b/drivers/usb/host/ehci-dbg.c index 495e2a3ef6f..9b347d76538 100644 --- a/drivers/usb/host/ehci-dbg.c +++ b/drivers/usb/host/ehci-dbg.c @@ -394,7 +394,7 @@ static void qh_lines ( mark = ' '; if (hw_curr == td->qtd_dma) mark = '*'; - else if (qh->hw_qtd_next == td->qtd_dma) + else if (qh->hw_qtd_next == cpu_to_le32(td->qtd_dma)) mark = '+'; else if (QTD_LENGTH (scratch)) { if (td->hw_alt_next == ehci->async->hw_alt_next) diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c index a63bb792e2c..84d2b93aca3 100644 --- a/drivers/usb/host/ehci-hcd.c +++ b/drivers/usb/host/ehci-hcd.c @@ -721,7 +721,7 @@ static int ehci_get_frame (struct usb_hcd *hcd) * the right sort of wakeup. */ -static int ehci_suspend (struct usb_hcd *hcd, u32 state) +static int ehci_suspend (struct usb_hcd *hcd, pm_message_t message) { struct ehci_hcd *ehci = hcd_to_ehci (hcd); @@ -729,7 +729,7 @@ static int ehci_suspend (struct usb_hcd *hcd, u32 state) msleep (100); #ifdef CONFIG_USB_SUSPEND - (void) usb_suspend_device (hcd->self.root_hub, state); + (void) usb_suspend_device (hcd->self.root_hub, message); #else usb_lock_device (hcd->self.root_hub); (void) ehci_hub_suspend (hcd); diff --git a/drivers/usb/host/ehci-mem.c b/drivers/usb/host/ehci-mem.c index 9938697ff36..5c38ad86948 100644 --- a/drivers/usb/host/ehci-mem.c +++ b/drivers/usb/host/ehci-mem.c @@ -156,8 +156,7 @@ static void ehci_mem_cleanup (struct ehci_hcd *ehci) ehci->periodic = NULL; /* shadow periodic table */ - if (ehci->pshadow) - kfree (ehci->pshadow); + kfree(ehci->pshadow); ehci->pshadow = NULL; } diff --git a/drivers/usb/host/ehci-sched.c b/drivers/usb/host/ehci-sched.c index f6c86354e30..2fa1ffee5ff 100644 --- a/drivers/usb/host/ehci-sched.c +++ b/drivers/usb/host/ehci-sched.c @@ -310,9 +310,9 @@ static int qh_link_periodic (struct ehci_hcd *ehci, struct ehci_qh *qh) for (i = qh->start; i < ehci->periodic_size; i += period) { union ehci_shadow *prev = &ehci->pshadow [i]; - u32 *hw_p = &ehci->periodic [i]; + __le32 *hw_p = &ehci->periodic [i]; union ehci_shadow here = *prev; - u32 type = 0; + __le32 type = 0; /* skip the iso nodes at list head */ while (here.ptr) { diff --git a/drivers/usb/host/ehci.h b/drivers/usb/host/ehci.h index 67988dba9eb..e763a8399a7 100644 --- a/drivers/usb/host/ehci.h +++ b/drivers/usb/host/ehci.h @@ -364,7 +364,7 @@ union ehci_shadow { struct ehci_itd *itd; /* Q_TYPE_ITD */ struct ehci_sitd *sitd; /* Q_TYPE_SITD */ struct ehci_fstn *fstn; /* Q_TYPE_FSTN */ - u32 *hw_next; /* (all types) */ + __le32 *hw_next; /* (all types) */ void *ptr; }; diff --git a/drivers/usb/host/ohci-omap.c b/drivers/usb/host/ohci-omap.c index 90285f180f8..8aab5907afe 100644 --- a/drivers/usb/host/ohci-omap.c +++ b/drivers/usb/host/ohci-omap.c @@ -458,9 +458,11 @@ static int ohci_hcd_omap_drv_remove(struct device *dev) /* states match PCI usage, always suspending the root hub except that * 4 ~= D3cold (ACPI D3) with clock off (resume sees reset). + * + * FIXME: above comment is not right, and code is wrong, too :-(. */ -static int ohci_omap_suspend(struct device *dev, u32 state, u32 level) +static int ohci_omap_suspend(struct device *dev, pm_message_t state, u32 level) { struct ohci_hcd *ohci = hcd_to_ohci(dev_get_drvdata(dev)); int status = -EINVAL; diff --git a/drivers/usb/host/ohci-pci.c b/drivers/usb/host/ohci-pci.c index b611582e6bc..57fd07d0054 100644 --- a/drivers/usb/host/ohci-pci.c +++ b/drivers/usb/host/ohci-pci.c @@ -54,7 +54,7 @@ ohci_pci_start (struct usb_hcd *hcd) if (pdev->vendor == PCI_VENDOR_ID_AMD && pdev->device == 0x740c) { ohci->flags = OHCI_QUIRK_AMD756; - ohci_info (ohci, "AMD756 erratum 4 workaround\n"); + ohci_dbg (ohci, "AMD756 erratum 4 workaround\n"); // also somewhat erratum 10 (suspend/resume issues) } @@ -68,7 +68,7 @@ ohci_pci_start (struct usb_hcd *hcd) */ else if (pdev->vendor == PCI_VENDOR_ID_OPTI && pdev->device == 0xc861) { - ohci_info (ohci, + ohci_dbg (ohci, "WARNING: OPTi workarounds unavailable\n"); } @@ -84,9 +84,20 @@ ohci_pci_start (struct usb_hcd *hcd) if (b && b->device == PCI_DEVICE_ID_NS_87560_LIO && b->vendor == PCI_VENDOR_ID_NS) { ohci->flags |= OHCI_QUIRK_SUPERIO; - ohci_info (ohci, "Using NSC SuperIO setup\n"); + ohci_dbg (ohci, "Using NSC SuperIO setup\n"); } } + + /* Check for Compaq's ZFMicro chipset, which needs short + * delays before control or bulk queues get re-activated + * in finish_unlinks() + */ + else if (pdev->vendor == PCI_VENDOR_ID_COMPAQ + && pdev->device == 0xa0f8) { + ohci->flags |= OHCI_QUIRK_ZFMICRO; + ohci_dbg (ohci, + "enabled Compaq ZFMicro chipset quirk\n"); + } } /* NOTE: there may have already been a first reset, to @@ -102,7 +113,7 @@ ohci_pci_start (struct usb_hcd *hcd) #ifdef CONFIG_PM -static int ohci_pci_suspend (struct usb_hcd *hcd, u32 state) +static int ohci_pci_suspend (struct usb_hcd *hcd, pm_message_t message) { struct ohci_hcd *ohci = hcd_to_ohci (hcd); @@ -111,7 +122,7 @@ static int ohci_pci_suspend (struct usb_hcd *hcd, u32 state) msleep (100); #ifdef CONFIG_USB_SUSPEND - (void) usb_suspend_device (hcd->self.root_hub, state); + (void) usb_suspend_device (hcd->self.root_hub, message); #else usb_lock_device (hcd->self.root_hub); (void) ohci_hub_suspend (hcd); diff --git a/drivers/usb/host/ohci-pxa27x.c b/drivers/usb/host/ohci-pxa27x.c index 6f3464a9577..e5bc1789d18 100644 --- a/drivers/usb/host/ohci-pxa27x.c +++ b/drivers/usb/host/ohci-pxa27x.c @@ -337,7 +337,7 @@ static int ohci_hcd_pxa27x_drv_remove(struct device *dev) return 0; } -static int ohci_hcd_pxa27x_drv_suspend(struct device *dev, u32 state, u32 level) +static int ohci_hcd_pxa27x_drv_suspend(struct device *dev, pm_message_t state, u32 level) { // struct platform_device *pdev = to_platform_device(dev); // struct usb_hcd *hcd = dev_get_drvdata(dev); @@ -346,7 +346,7 @@ static int ohci_hcd_pxa27x_drv_suspend(struct device *dev, u32 state, u32 level) return 0; } -static int ohci_hcd_pxa27x_drv_resume(struct device *dev, u32 state) +static int ohci_hcd_pxa27x_drv_resume(struct device *dev, u32 level) { // struct platform_device *pdev = to_platform_device(dev); // struct usb_hcd *hcd = dev_get_drvdata(dev); diff --git a/drivers/usb/host/ohci-q.c b/drivers/usb/host/ohci-q.c index c90114a7727..e372306ed0d 100644 --- a/drivers/usb/host/ohci-q.c +++ b/drivers/usb/host/ohci-q.c @@ -1021,6 +1021,8 @@ rescan_this: if (ohci->ed_controltail) { command |= OHCI_CLF; + if (ohci->flags & OHCI_QUIRK_ZFMICRO) + mdelay(1); if (!(ohci->hc_control & OHCI_CTRL_CLE)) { control |= OHCI_CTRL_CLE; ohci_writel (ohci, 0, @@ -1029,6 +1031,8 @@ rescan_this: } if (ohci->ed_bulktail) { command |= OHCI_BLF; + if (ohci->flags & OHCI_QUIRK_ZFMICRO) + mdelay(1); if (!(ohci->hc_control & OHCI_CTRL_BLE)) { control |= OHCI_CTRL_BLE; ohci_writel (ohci, 0, @@ -1039,12 +1043,17 @@ rescan_this: /* CLE/BLE to enable, CLF/BLF to (maybe) kickstart */ if (control) { ohci->hc_control |= control; + if (ohci->flags & OHCI_QUIRK_ZFMICRO) + mdelay(1); ohci_writel (ohci, ohci->hc_control, &ohci->regs->control); } - if (command) + if (command) { + if (ohci->flags & OHCI_QUIRK_ZFMICRO) + mdelay(1); ohci_writel (ohci, command, &ohci->regs->cmdstatus); - } + } + } } diff --git a/drivers/usb/host/ohci.h b/drivers/usb/host/ohci.h index 2ba6e2b0210..22e1ac138ac 100644 --- a/drivers/usb/host/ohci.h +++ b/drivers/usb/host/ohci.h @@ -396,6 +396,7 @@ struct ohci_hcd { #define OHCI_QUIRK_SUPERIO 0x02 /* natsemi */ #define OHCI_QUIRK_INITRESET 0x04 /* SiS, OPTi, ... */ #define OHCI_BIG_ENDIAN 0x08 /* big endian HC */ +#define OHCI_QUIRK_ZFMICRO 0x10 /* Compaq ZFMicro chipset*/ // there are also chip quirks/bugs in init logic }; diff --git a/drivers/usb/host/uhci-hcd.c b/drivers/usb/host/uhci-hcd.c index 324a1a9bbdb..49bd83ee0c7 100644 --- a/drivers/usb/host/uhci-hcd.c +++ b/drivers/usb/host/uhci-hcd.c @@ -716,7 +716,7 @@ static void uhci_stop(struct usb_hcd *hcd) } #ifdef CONFIG_PM -static int uhci_suspend(struct usb_hcd *hcd, u32 state) +static int uhci_suspend(struct usb_hcd *hcd, pm_message_t message) { struct uhci_hcd *uhci = hcd_to_uhci(hcd); @@ -890,8 +890,7 @@ up_failed: debugfs_remove(uhci_debugfs_root); debug_failed: - if (errbuf) - kfree(errbuf); + kfree(errbuf); errbuf_failed: @@ -906,9 +905,7 @@ static void __exit uhci_hcd_cleanup(void) warn("not all urb_priv's were freed!"); debugfs_remove(uhci_debugfs_root); - - if (errbuf) - kfree(errbuf); + kfree(errbuf); } module_init(uhci_hcd_init); diff --git a/drivers/usb/input/aiptek.c b/drivers/usb/input/aiptek.c index d7fea9ea301..2d76be62f4e 100644 --- a/drivers/usb/input/aiptek.c +++ b/drivers/usb/input/aiptek.c @@ -2138,6 +2138,7 @@ aiptek_probe(struct usb_interface *intf, const struct usb_device_id *id) aiptek->inputdev.id.vendor = le16_to_cpu(usbdev->descriptor.idVendor); aiptek->inputdev.id.product = le16_to_cpu(usbdev->descriptor.idProduct); aiptek->inputdev.id.version = le16_to_cpu(usbdev->descriptor.bcdDevice); + aiptek->inputdev.dev = &intf->dev; aiptek->usbdev = usbdev; aiptek->ifnum = intf->altsetting[0].desc.bInterfaceNumber; diff --git a/drivers/usb/input/hid-core.c b/drivers/usb/input/hid-core.c index 7662cf4e262..869ff73690a 100644 --- a/drivers/usb/input/hid-core.c +++ b/drivers/usb/input/hid-core.c @@ -558,8 +558,7 @@ static void hid_free_device(struct hid_device *device) } } - if (device->rdesc) - kfree(device->rdesc); + kfree(device->rdesc); kfree(device); } @@ -1790,12 +1789,12 @@ static int hid_probe(struct usb_interface *intf, const struct usb_device_id *id) return 0; } -static int hid_suspend(struct usb_interface *intf, u32 state) +static int hid_suspend(struct usb_interface *intf, pm_message_t message) { struct hid_device *hid = usb_get_intfdata (intf); usb_kill_urb(hid->urbin); - intf->dev.power.power_state = state; + intf->dev.power.power_state = PMSG_SUSPEND; dev_dbg(&intf->dev, "suspend\n"); return 0; } @@ -1805,7 +1804,7 @@ static int hid_resume(struct usb_interface *intf) struct hid_device *hid = usb_get_intfdata (intf); int status; - intf->dev.power.power_state = PM_SUSPEND_ON; + intf->dev.power.power_state = PMSG_ON; if (hid->open) status = usb_submit_urb(hid->urbin, GFP_NOIO); else diff --git a/drivers/usb/media/dabusb.c b/drivers/usb/media/dabusb.c index 8823297d219..6ca2fae99d2 100644 --- a/drivers/usb/media/dabusb.c +++ b/drivers/usb/media/dabusb.c @@ -138,8 +138,7 @@ static int dabusb_free_queue (struct list_head *q) #ifdef DEBUG dump_urb(b->purb); #endif - if (b->purb->transfer_buffer) - kfree (b->purb->transfer_buffer); + kfree(b->purb->transfer_buffer); usb_free_urb(b->purb); tmp = p->next; list_del (p); diff --git a/drivers/usb/media/ov511.c b/drivers/usb/media/ov511.c index 0fd7ffed3a9..d6051822416 100644 --- a/drivers/usb/media/ov511.c +++ b/drivers/usb/media/ov511.c @@ -3915,10 +3915,8 @@ ov51x_do_dealloc(struct usb_ov511 *ov) ov->tempfbuf = NULL; for (i = 0; i < OV511_NUMSBUF; i++) { - if (ov->sbuf[i].data) { - kfree(ov->sbuf[i].data); - ov->sbuf[i].data = NULL; - } + kfree(ov->sbuf[i].data); + ov->sbuf[i].data = NULL; } for (i = 0; i < OV511_NUMFRAMES; i++) { @@ -5954,10 +5952,8 @@ error: up(&ov->cbuf_lock); } - if (ov) { - kfree(ov); - ov = NULL; - } + kfree(ov); + ov = NULL; error_out: err("Camera initialization failed"); diff --git a/drivers/usb/media/se401.c b/drivers/usb/media/se401.c index 685bdae5cb6..f69e443cd1b 100644 --- a/drivers/usb/media/se401.c +++ b/drivers/usb/media/se401.c @@ -868,13 +868,14 @@ static void usb_se401_remove_disconnected (struct usb_se401 *se401) se401->dev = NULL; - for (i=0; i<SE401_NUMSBUF; i++) if (se401->urb[i]) { - usb_kill_urb(se401->urb[i]); - usb_free_urb(se401->urb[i]); - se401->urb[i] = NULL; - kfree(se401->sbuf[i].data); - } - for (i=0; i<SE401_NUMSCRATCH; i++) if (se401->scratch[i].data) { + for (i=0; i<SE401_NUMSBUF; i++) + if (se401->urb[i]) { + usb_kill_urb(se401->urb[i]); + usb_free_urb(se401->urb[i]); + se401->urb[i] = NULL; + kfree(se401->sbuf[i].data); + } + for (i=0; i<SE401_NUMSCRATCH; i++) { kfree(se401->scratch[i].data); } if (se401->inturb) { diff --git a/drivers/usb/media/usbvideo.c b/drivers/usb/media/usbvideo.c index 298484aa27d..24efb21969c 100644 --- a/drivers/usb/media/usbvideo.c +++ b/drivers/usb/media/usbvideo.c @@ -1169,10 +1169,8 @@ static int usbvideo_v4l_open(struct inode *inode, struct file *file) } RingQueue_Free(&uvd->dp); for (i=0; i < USBVIDEO_NUMSBUF; i++) { - if (uvd->sbuf[i].data != NULL) { - kfree (uvd->sbuf[i].data); - uvd->sbuf[i].data = NULL; - } + kfree(uvd->sbuf[i].data); + uvd->sbuf[i].data = NULL; } } } diff --git a/drivers/usb/media/w9968cf.c b/drivers/usb/media/w9968cf.c index 689e79e4bce..ca9f3a30634 100644 --- a/drivers/usb/media/w9968cf.c +++ b/drivers/usb/media/w9968cf.c @@ -3624,10 +3624,8 @@ w9968cf_usb_probe(struct usb_interface* intf, const struct usb_device_id* id) return 0; fail: /* Free unused memory */ - if (cam->control_buffer) - kfree(cam->control_buffer); - if (cam->data_buffer) - kfree(cam->data_buffer); + kfree(cam->control_buffer); + kfree(cam->data_buffer); if (cam->v4ldev) video_device_release(cam->v4ldev); up(&cam->dev_sem); diff --git a/drivers/usb/misc/auerswald.c b/drivers/usb/misc/auerswald.c index a530bb976e4..6f7994f5a71 100644 --- a/drivers/usb/misc/auerswald.c +++ b/drivers/usb/misc/auerswald.c @@ -705,16 +705,12 @@ static int auerchain_control_msg (pauerchain_t acp, struct usb_device *dev, unsi /* free a single auerbuf */ static void auerbuf_free (pauerbuf_t bp) { - if (bp->bufp) { - kfree (bp->bufp); - } - if (bp->dr) { - kfree (bp->dr); - } + kfree(bp->bufp); + kfree(bp->dr); if (bp->urbp) { - usb_free_urb (bp->urbp); + usb_free_urb(bp->urbp); } - kfree (bp); + kfree(bp); } /* free the buffers from an auerbuf list */ @@ -1093,14 +1089,12 @@ exit: */ static void auerswald_int_free (pauerswald_t cp) { - if (cp->inturbp) { - usb_free_urb (cp->inturbp); - cp->inturbp = NULL; - } - if (cp->intbufp) { - kfree (cp->intbufp); - cp->intbufp = NULL; - } + if (cp->inturbp) { + usb_free_urb(cp->inturbp); + cp->inturbp = NULL; + } + kfree(cp->intbufp); + cp->intbufp = NULL; } /* This function is called to activate the interrupt diff --git a/drivers/usb/misc/sisusbvga/sisusb.c b/drivers/usb/misc/sisusbvga/sisusb.c index be163b33016..57b82d53a94 100644 --- a/drivers/usb/misc/sisusbvga/sisusb.c +++ b/drivers/usb/misc/sisusbvga/sisusb.c @@ -3104,6 +3104,7 @@ static void sisusb_disconnect(struct usb_interface *intf) static struct usb_device_id sisusb_table [] = { { USB_DEVICE(0x0711, 0x0900) }, + { USB_DEVICE(0x182d, 0x021c) }, { } }; @@ -3114,7 +3115,7 @@ static struct usb_driver sisusb_driver = { .name = "sisusb", .probe = sisusb_probe, .disconnect = sisusb_disconnect, - .id_table = sisusb_table + .id_table = sisusb_table, }; static int __init usb_sisusb_init(void) diff --git a/drivers/usb/net/pegasus.c b/drivers/usb/net/pegasus.c index f6c19d73b7d..a02be795d63 100644 --- a/drivers/usb/net/pegasus.c +++ b/drivers/usb/net/pegasus.c @@ -1364,11 +1364,18 @@ static void pegasus_disconnect(struct usb_interface *intf) free_netdev(pegasus->net); } -static int pegasus_suspend (struct usb_interface *intf, pm_message_t state) +static int pegasus_suspend (struct usb_interface *intf, pm_message_t message) { struct pegasus *pegasus = usb_get_intfdata(intf); netif_device_detach (pegasus->net); + if (netif_running(pegasus->net)) { + cancel_delayed_work(&pegasus->carrier_check); + + usb_kill_urb(pegasus->rx_urb); + usb_kill_urb(pegasus->intr_urb); + } + intf->dev.power.power_state = PMSG_SUSPEND; return 0; } @@ -1376,7 +1383,20 @@ static int pegasus_resume (struct usb_interface *intf) { struct pegasus *pegasus = usb_get_intfdata(intf); + intf->dev.power.power_state = PMSG_ON; netif_device_attach (pegasus->net); + if (netif_running(pegasus->net)) { + pegasus->rx_urb->status = 0; + pegasus->rx_urb->actual_length = 0; + read_bulk_callback(pegasus->rx_urb, 0); + + pegasus->intr_urb->status = 0; + pegasus->intr_urb->actual_length = 0; + intr_callback(pegasus->intr_urb, 0); + + queue_delayed_work(pegasus_workqueue, &pegasus->carrier_check, + CARRIER_CHECK_DELAY); + } return 0; } diff --git a/drivers/usb/net/usbnet.c b/drivers/usb/net/usbnet.c index dd8b4456ea3..bbaef047d53 100644 --- a/drivers/usb/net/usbnet.c +++ b/drivers/usb/net/usbnet.c @@ -426,7 +426,7 @@ static void skb_return (struct usbnet *dev, struct sk_buff *skb) dev->stats.rx_bytes += skb->len; if (netif_msg_rx_status (dev)) - devdbg (dev, "< rx, len %d, type 0x%x", + devdbg (dev, "< rx, len %zd, type 0x%x", skb->len + sizeof (struct ethhdr), skb->protocol); memset (skb->cb, 0, sizeof (struct skb_data)); status = netif_rx (skb); @@ -3732,11 +3732,17 @@ out: #ifdef CONFIG_PM -static int usbnet_suspend (struct usb_interface *intf, u32 state) +static int usbnet_suspend (struct usb_interface *intf, pm_message_t message) { struct usbnet *dev = usb_get_intfdata(intf); + /* accelerate emptying of the rx and queues, to avoid + * having everything error out. + */ netif_device_detach (dev->net); + (void) unlink_urbs (dev, &dev->rxq); + (void) unlink_urbs (dev, &dev->txq); + intf->dev.power.power_state = PMSG_SUSPEND; return 0; } @@ -3744,7 +3750,9 @@ static int usbnet_resume (struct usb_interface *intf) { struct usbnet *dev = usb_get_intfdata(intf); + intf->dev.power.power_state = PMSG_ON; netif_device_attach (dev->net); + tasklet_schedule (&dev->bh); return 0; } @@ -4009,10 +4017,23 @@ static const struct usb_device_id products [] = { .idProduct = 0x9050, /* C-860 */ ZAURUS_MASTER_INTERFACE, .driver_info = ZAURUS_PXA_INFO, +}, + #ifdef CONFIG_USB_ZAURUS - /* at least some (reports vary) C-860 units have very different - * lies about their standards support. + /* at least some (reports vary) PXA units have very different + * lies about their standards support: they claim to be cell + * phones giving direct radio access (which they aren't). */ +{ + .match_flags = USB_DEVICE_ID_MATCH_INT_INFO + | USB_DEVICE_ID_MATCH_DEVICE, + .idVendor = 0x04DD, + /* Sharp ROM v1.32 */ + .idProduct = 0x8006, /* SL-5600 */ + .bInterfaceClass = USB_CLASS_COMM, + .bInterfaceSubClass = USB_CDC_SUBCLASS_MDLM, + .bInterfaceProtocol = USB_CDC_PROTO_NONE, + .driver_info = (unsigned long) &zaurus_pxa_mdlm_info, }, { .match_flags = USB_DEVICE_ID_MATCH_INT_INFO | USB_DEVICE_ID_MATCH_DEVICE, @@ -4023,8 +4044,8 @@ static const struct usb_device_id products [] = { .bInterfaceSubClass = USB_CDC_SUBCLASS_MDLM, .bInterfaceProtocol = USB_CDC_PROTO_NONE, .driver_info = (unsigned long) &zaurus_pxa_mdlm_info, -#endif }, +#endif /* Olympus has some models with a Zaurus-compatible option. * R-1000 uses a FreeScale i.MXL cpu (ARMv4T) diff --git a/drivers/usb/net/zd1201.c b/drivers/usb/net/zd1201.c index 938025e2c64..c81cd0a619b 100644 --- a/drivers/usb/net/zd1201.c +++ b/drivers/usb/net/zd1201.c @@ -106,8 +106,7 @@ int zd1201_fw_upload(struct usb_device *dev, int apfw) err = 0; exit: - if (buf) - kfree(buf); + kfree(buf); release_firmware(fw_entry); return err; } diff --git a/drivers/usb/serial/belkin_sa.c b/drivers/usb/serial/belkin_sa.c index 86994d117c4..abb1b2c543b 100644 --- a/drivers/usb/serial/belkin_sa.c +++ b/drivers/usb/serial/belkin_sa.c @@ -202,8 +202,7 @@ static void belkin_sa_shutdown (struct usb_serial *serial) for (i=0; i < serial->num_ports; ++i) { /* My special items, the standard routines free my urbs */ priv = usb_get_serial_port_data(serial->port[i]); - if (priv) - kfree(priv); + kfree(priv); } } diff --git a/drivers/usb/serial/cypress_m8.c b/drivers/usb/serial/cypress_m8.c index db8f472d9e3..d165f42d560 100644 --- a/drivers/usb/serial/cypress_m8.c +++ b/drivers/usb/serial/cypress_m8.c @@ -1340,9 +1340,8 @@ static struct cypress_buf *cypress_buf_alloc(unsigned int size) static void cypress_buf_free(struct cypress_buf *cb) { - if (cb != NULL) { - if (cb->buf_buf != NULL) - kfree(cb->buf_buf); + if (cb) { + kfree(cb->buf_buf); kfree(cb); } } diff --git a/drivers/usb/serial/digi_acceleport.c b/drivers/usb/serial/digi_acceleport.c index 25f92788a6d..a19a47f6cf1 100644 --- a/drivers/usb/serial/digi_acceleport.c +++ b/drivers/usb/serial/digi_acceleport.c @@ -568,6 +568,9 @@ static struct usb_serial_device_type digi_acceleport_4_device = { * and the sleep. In other words, spin_unlock_irqrestore and * interruptible_sleep_on_timeout are "atomic" with respect to * wake ups. This is used to implement condition variables. +* +* interruptible_sleep_on_timeout is deprecated and has been replaced +* with the equivalent code. */ static inline long cond_wait_interruptible_timeout_irqrestore( @@ -576,13 +579,12 @@ static inline long cond_wait_interruptible_timeout_irqrestore( { DEFINE_WAIT(wait); - prepare_to_wait(q, &wait, TASK_UNINTERRUPTIBLE); + prepare_to_wait(q, &wait, TASK_INTERRUPTIBLE); spin_unlock_irqrestore(lock, flags); timeout = schedule_timeout(timeout); finish_wait(q, &wait); return timeout; - } @@ -1596,7 +1598,7 @@ dbg( "digi_close: TOP: port=%d, open_count=%d", priv->dp_port_num, port->open_co dbg( "digi_close: write oob failed, ret=%d", ret ); /* wait for final commands on oob port to complete */ - prepare_to_wait(&priv->dp_flush_wait, &wait, TASK_UNINTERRUPTIBLE); + prepare_to_wait(&priv->dp_flush_wait, &wait, TASK_INTERRUPTIBLE); schedule_timeout(DIGI_CLOSE_TIMEOUT); finish_wait(&priv->dp_flush_wait, &wait); @@ -1995,7 +1997,7 @@ opcode, line, status, val ); } else if( opcode == DIGI_CMD_IFLUSH_FIFO ) { - wake_up( &priv->dp_flush_wait ); + wake_up_interruptible( &priv->dp_flush_wait ); } diff --git a/drivers/usb/serial/empeg.c b/drivers/usb/serial/empeg.c index 4d46394f351..8d562ab454a 100644 --- a/drivers/usb/serial/empeg.c +++ b/drivers/usb/serial/empeg.c @@ -550,8 +550,7 @@ failed_usb_register: failed_usb_serial_register: for (i = 0; i < NUM_URBS; ++i) { if (write_urb_pool[i]) { - if (write_urb_pool[i]->transfer_buffer) - kfree(write_urb_pool[i]->transfer_buffer); + kfree(write_urb_pool[i]->transfer_buffer); usb_free_urb(write_urb_pool[i]); } } @@ -575,8 +574,7 @@ static void __exit empeg_exit (void) * the host controllers get fixed to set urb->dev = NULL after * the urb is finished. Otherwise this call oopses. */ /* usb_kill_urb(write_urb_pool[i]); */ - if (write_urb_pool[i]->transfer_buffer) - kfree(write_urb_pool[i]->transfer_buffer); + kfree(write_urb_pool[i]->transfer_buffer); usb_free_urb (write_urb_pool[i]); } } diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c index 4afd905fe2f..4c788c767a9 100644 --- a/drivers/usb/serial/ftdi_sio.c +++ b/drivers/usb/serial/ftdi_sio.c @@ -1347,9 +1347,7 @@ static int ftdi_common_startup (struct usb_serial *serial) priv->flags = ASYNC_LOW_LATENCY; /* Increase the size of read buffers */ - if (port->bulk_in_buffer) { - kfree (port->bulk_in_buffer); - } + kfree(port->bulk_in_buffer); port->bulk_in_buffer = kmalloc (BUFSZ, GFP_KERNEL); if (!port->bulk_in_buffer) { kfree (priv); @@ -1365,10 +1363,8 @@ static int ftdi_common_startup (struct usb_serial *serial) usb_free_urb (port->write_urb); port->write_urb = NULL; } - if (port->bulk_out_buffer) { - kfree (port->bulk_out_buffer); - port->bulk_out_buffer = NULL; - } + kfree(port->bulk_out_buffer); + port->bulk_out_buffer = NULL; usb_set_serial_port_data(serial->port[0], priv); diff --git a/drivers/usb/serial/io_edgeport.c b/drivers/usb/serial/io_edgeport.c index e35b5adcd5f..04bfe279d76 100644 --- a/drivers/usb/serial/io_edgeport.c +++ b/drivers/usb/serial/io_edgeport.c @@ -951,9 +951,7 @@ static void edge_bulk_out_cmd_callback (struct urb *urb, struct pt_regs *regs) /* clean up the transfer buffer */ - if (urb->transfer_buffer != NULL) { - kfree(urb->transfer_buffer); - } + kfree(urb->transfer_buffer); /* Free the command urb */ usb_free_urb (urb); @@ -1266,16 +1264,12 @@ static void edge_close (struct usb_serial_port *port, struct file * filp) if (edge_port->write_urb) { /* if this urb had a transfer buffer already (old transfer) free it */ - if (edge_port->write_urb->transfer_buffer != NULL) { - kfree(edge_port->write_urb->transfer_buffer); - } - usb_free_urb (edge_port->write_urb); + kfree(edge_port->write_urb->transfer_buffer); + usb_free_urb(edge_port->write_urb); edge_port->write_urb = NULL; } - if (edge_port->txfifo.fifo) { - kfree(edge_port->txfifo.fifo); - edge_port->txfifo.fifo = NULL; - } + kfree(edge_port->txfifo.fifo); + edge_port->txfifo.fifo = NULL; dbg("%s exited", __FUNCTION__); } @@ -1419,11 +1413,9 @@ static void send_more_port_data(struct edgeport_serial *edge_serial, struct edge // get a pointer to the write_urb urb = edge_port->write_urb; - /* if this urb had a transfer buffer already (old transfer) free it */ - if (urb->transfer_buffer != NULL) { - kfree(urb->transfer_buffer); - urb->transfer_buffer = NULL; - } + /* make sure transfer buffer is freed */ + kfree(urb->transfer_buffer); + urb->transfer_buffer = NULL; /* build the data header for the buffer and port that we are about to send out */ count = fifo->count; diff --git a/drivers/usb/serial/io_ti.c b/drivers/usb/serial/io_ti.c index 6c96fdaec36..ebf9967f7c8 100644 --- a/drivers/usb/serial/io_ti.c +++ b/drivers/usb/serial/io_ti.c @@ -2845,9 +2845,8 @@ static struct edge_buf *edge_buf_alloc(unsigned int size) void edge_buf_free(struct edge_buf *eb) { - if (eb != NULL) { - if (eb->buf_buf != NULL) - kfree(eb->buf_buf); + if (eb) { + kfree(eb->buf_buf); kfree(eb); } } diff --git a/drivers/usb/serial/kl5kusb105.c b/drivers/usb/serial/kl5kusb105.c index 49c602a0b4d..a11e829e38c 100644 --- a/drivers/usb/serial/kl5kusb105.c +++ b/drivers/usb/serial/kl5kusb105.c @@ -341,8 +341,7 @@ static void klsi_105_shutdown (struct usb_serial *serial) * finished. Otherwise this call * oopses. */ /* usb_kill_urb(write_urbs[j]); */ - if (write_urbs[j]->transfer_buffer) - kfree(write_urbs[j]->transfer_buffer); + kfree(write_urbs[j]->transfer_buffer); usb_free_urb (write_urbs[j]); } } diff --git a/drivers/usb/serial/omninet.c b/drivers/usb/serial/omninet.c index a1cba4b5fa2..b5f2c06d4f3 100644 --- a/drivers/usb/serial/omninet.c +++ b/drivers/usb/serial/omninet.c @@ -178,7 +178,6 @@ static void omninet_close (struct usb_serial_port *port, struct file * filp) { struct usb_serial *serial = port->serial; struct usb_serial_port *wport; - struct omninet_data *od; dbg("%s - port %d", __FUNCTION__, port->number); @@ -186,9 +185,7 @@ static void omninet_close (struct usb_serial_port *port, struct file * filp) usb_kill_urb(wport->write_urb); usb_kill_urb(port->read_urb); - od = usb_get_serial_port_data(port); - if (od) - kfree(od); + kfree(usb_get_serial_port_data(port)); } diff --git a/drivers/usb/serial/pl2303.c b/drivers/usb/serial/pl2303.c index 3368d2b0412..7eab5d4cf3a 100644 --- a/drivers/usb/serial/pl2303.c +++ b/drivers/usb/serial/pl2303.c @@ -94,6 +94,7 @@ static struct usb_device_id id_table [] = { { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_ID) }, { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_ID) }, { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65) }, + { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) }, { } /* Terminating entry */ }; @@ -677,6 +678,9 @@ static int pl2303_tiocmset (struct usb_serial_port *port, struct file *file, unsigned long flags; u8 control; + if (!usb_get_intfdata(port->serial->interface)) + return -ENODEV; + spin_lock_irqsave (&priv->lock, flags); if (set & TIOCM_RTS) priv->line_control |= CONTROL_RTS; @@ -702,6 +706,9 @@ static int pl2303_tiocmget (struct usb_serial_port *port, struct file *file) dbg("%s (%d)", __FUNCTION__, port->number); + if (!usb_get_intfdata(port->serial->interface)) + return -ENODEV; + spin_lock_irqsave (&priv->lock, flags); mcr = priv->line_control; status = priv->line_status; @@ -811,15 +818,40 @@ static void pl2303_shutdown (struct usb_serial *serial) } } +static void pl2303_update_line_status(struct usb_serial_port *port, + unsigned char *data, + unsigned int actual_length) +{ + + struct pl2303_private *priv = usb_get_serial_port_data(port); + unsigned long flags; + u8 status_idx = UART_STATE; + u8 length = UART_STATE; + + if ((le16_to_cpu(port->serial->dev->descriptor.idVendor) == SIEMENS_VENDOR_ID) && + (le16_to_cpu(port->serial->dev->descriptor.idProduct) == SIEMENS_PRODUCT_ID_X65)) { + length = 1; + status_idx = 0; + } + + if (actual_length < length) + goto exit; + + /* Save off the uart status for others to look at */ + spin_lock_irqsave(&priv->lock, flags); + priv->line_status = data[status_idx]; + spin_unlock_irqrestore(&priv->lock, flags); + +exit: + return; +} static void pl2303_read_int_callback (struct urb *urb, struct pt_regs *regs) { struct usb_serial_port *port = (struct usb_serial_port *) urb->context; - struct pl2303_private *priv = usb_get_serial_port_data(port); unsigned char *data = urb->transfer_buffer; - unsigned long flags; + unsigned int actual_length = urb->actual_length; int status; - u8 uart_state; dbg("%s (%d)", __FUNCTION__, port->number); @@ -838,19 +870,9 @@ static void pl2303_read_int_callback (struct urb *urb, struct pt_regs *regs) goto exit; } - usb_serial_debug_data(debug, &port->dev, __FUNCTION__, urb->actual_length, urb->transfer_buffer); + pl2303_update_line_status(port, data, actual_length); - if (urb->actual_length < UART_STATE) - goto exit; - - /* Save off the uart status for others to look at */ - uart_state = data[UART_STATE]; - spin_lock_irqsave(&priv->lock, flags); - uart_state |= (priv->line_status & UART_STATE_TRANSIENT_MASK); - priv->line_status = uart_state; - spin_unlock_irqrestore(&priv->lock, flags); - exit: status = usb_submit_urb (urb, GFP_ATOMIC); if (status) @@ -1022,9 +1044,8 @@ static struct pl2303_buf *pl2303_buf_alloc(unsigned int size) static void pl2303_buf_free(struct pl2303_buf *pb) { - if (pb != NULL) { - if (pb->buf_buf != NULL) - kfree(pb->buf_buf); + if (pb) { + kfree(pb->buf_buf); kfree(pb); } } diff --git a/drivers/usb/serial/pl2303.h b/drivers/usb/serial/pl2303.h index 6c1b4712dc2..b734c4003c5 100644 --- a/drivers/usb/serial/pl2303.h +++ b/drivers/usb/serial/pl2303.h @@ -55,3 +55,6 @@ #define SIEMENS_VENDOR_ID 0x11f5 #define SIEMENS_PRODUCT_ID_X65 0x0003 + +#define SYNTECH_VENDOR_ID 0x0745 +#define SYNTECH_PRODUCT_ID 0x0001 diff --git a/drivers/usb/serial/ti_usb_3410_5052.c b/drivers/usb/serial/ti_usb_3410_5052.c index 98054876cca..59c88de3e7a 100644 --- a/drivers/usb/serial/ti_usb_3410_5052.c +++ b/drivers/usb/serial/ti_usb_3410_5052.c @@ -517,8 +517,7 @@ static void ti_shutdown(struct usb_serial *serial) } } - if (tdev) - kfree(tdev); + kfree(tdev); usb_set_serial_data(serial, NULL); } diff --git a/drivers/usb/serial/visor.c b/drivers/usb/serial/visor.c index 69d313e98fa..31c57adcb62 100644 --- a/drivers/usb/serial/visor.c +++ b/drivers/usb/serial/visor.c @@ -215,6 +215,8 @@ static struct usb_device_id id_table [] = { .driver_info = (kernel_ulong_t)&palm_os_4_probe }, { USB_DEVICE(PALM_VENDOR_ID, PALM_TUNGSTEN_T_ID), .driver_info = (kernel_ulong_t)&palm_os_4_probe }, + { USB_DEVICE(PALM_VENDOR_ID, PALM_TREO_650), + .driver_info = (kernel_ulong_t)&palm_os_4_probe }, { USB_DEVICE(PALM_VENDOR_ID, PALM_TUNGSTEN_Z_ID), .driver_info = (kernel_ulong_t)&palm_os_4_probe }, { USB_DEVICE(PALM_VENDOR_ID, PALM_ZIRE31_ID), @@ -237,6 +239,8 @@ static struct usb_device_id id_table [] = { .driver_info = (kernel_ulong_t)&palm_os_4_probe }, { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_SPH_I500_ID), .driver_info = (kernel_ulong_t)&palm_os_4_probe }, + { USB_DEVICE(TAPWAVE_VENDOR_ID, TAPWAVE_ZODIAC_ID), + .driver_info = (kernel_ulong_t)&palm_os_4_probe }, { USB_DEVICE(GARMIN_VENDOR_ID, GARMIN_IQUE_3600_ID), .driver_info = (kernel_ulong_t)&palm_os_4_probe }, { USB_DEVICE(ACEECA_VENDOR_ID, ACEECA_MEZ1000_ID), @@ -273,6 +277,7 @@ static struct usb_device_id id_table_combined [] = { { USB_DEVICE(PALM_VENDOR_ID, PALM_M125_ID) }, { USB_DEVICE(PALM_VENDOR_ID, PALM_M130_ID) }, { USB_DEVICE(PALM_VENDOR_ID, PALM_TUNGSTEN_T_ID) }, + { USB_DEVICE(PALM_VENDOR_ID, PALM_TREO_650) }, { USB_DEVICE(PALM_VENDOR_ID, PALM_TUNGSTEN_Z_ID) }, { USB_DEVICE(PALM_VENDOR_ID, PALM_ZIRE31_ID) }, { USB_DEVICE(PALM_VENDOR_ID, PALM_ZIRE_ID) }, @@ -286,6 +291,7 @@ static struct usb_device_id id_table_combined [] = { { USB_DEVICE(SONY_VENDOR_ID, SONY_CLIE_TJ25_ID) }, { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_SCH_I330_ID) }, { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_SPH_I500_ID) }, + { USB_DEVICE(TAPWAVE_VENDOR_ID, TAPWAVE_ZODIAC_ID) }, { USB_DEVICE(GARMIN_VENDOR_ID, GARMIN_IQUE_3600_ID) }, { USB_DEVICE(ACEECA_VENDOR_ID, ACEECA_MEZ1000_ID) }, { USB_DEVICE(KYOCERA_VENDOR_ID, KYOCERA_7135_ID) }, diff --git a/drivers/usb/serial/visor.h b/drivers/usb/serial/visor.h index a2fa2c61a00..b84d1cb4c69 100644 --- a/drivers/usb/serial/visor.h +++ b/drivers/usb/serial/visor.h @@ -30,6 +30,7 @@ #define PALM_M125_ID 0x0040 #define PALM_M130_ID 0x0050 #define PALM_TUNGSTEN_T_ID 0x0060 +#define PALM_TREO_650 0x0061 #define PALM_TUNGSTEN_Z_ID 0x0031 #define PALM_ZIRE31_ID 0x0061 #define PALM_ZIRE_ID 0x0070 @@ -49,6 +50,9 @@ #define SAMSUNG_SCH_I330_ID 0x8001 #define SAMSUNG_SPH_I500_ID 0x6601 +#define TAPWAVE_VENDOR_ID 0x12EF +#define TAPWAVE_ZODIAC_ID 0x0100 + #define GARMIN_VENDOR_ID 0x091E #define GARMIN_IQUE_3600_ID 0x0004 diff --git a/drivers/usb/storage/sddr55.c b/drivers/usb/storage/sddr55.c index 229ca181716..8451779f426 100644 --- a/drivers/usb/storage/sddr55.c +++ b/drivers/usb/storage/sddr55.c @@ -119,10 +119,8 @@ static int sddr55_status(struct us_data *us) /* expect to get short transfer if no card fitted */ if (result == USB_STOR_XFER_SHORT || result == USB_STOR_XFER_STALLED) { /* had a short transfer, no card inserted, free map memory */ - if (info->lba_to_pba) - kfree(info->lba_to_pba); - if (info->pba_to_lba) - kfree(info->pba_to_lba); + kfree(info->lba_to_pba); + kfree(info->pba_to_lba); info->lba_to_pba = NULL; info->pba_to_lba = NULL; @@ -649,18 +647,14 @@ static int sddr55_read_map(struct us_data *us) { return -1; } - if (info->lba_to_pba) - kfree(info->lba_to_pba); - if (info->pba_to_lba) - kfree(info->pba_to_lba); + kfree(info->lba_to_pba); + kfree(info->pba_to_lba); info->lba_to_pba = kmalloc(numblocks*sizeof(int), GFP_NOIO); info->pba_to_lba = kmalloc(numblocks*sizeof(int), GFP_NOIO); if (info->lba_to_pba == NULL || info->pba_to_lba == NULL) { - if (info->lba_to_pba != NULL) - kfree(info->lba_to_pba); - if (info->pba_to_lba != NULL) - kfree(info->pba_to_lba); + kfree(info->lba_to_pba); + kfree(info->pba_to_lba); info->lba_to_pba = NULL; info->pba_to_lba = NULL; kfree(buffer); @@ -728,10 +722,8 @@ static void sddr55_card_info_destructor(void *extra) { if (!extra) return; - if (info->lba_to_pba) - kfree(info->lba_to_pba); - if (info->pba_to_lba) - kfree(info->pba_to_lba); + kfree(info->lba_to_pba); + kfree(info->pba_to_lba); } diff --git a/drivers/usb/storage/transport.c b/drivers/usb/storage/transport.c index d2c3d2fa082..9743e289cd3 100644 --- a/drivers/usb/storage/transport.c +++ b/drivers/usb/storage/transport.c @@ -996,7 +996,7 @@ int usb_stor_Bulk_transport(struct scsi_cmnd *srb, struct us_data *us) * command phase and the data phase. Some devices need a little * more than that, probably because of clock rate inaccuracies. */ if (unlikely(us->flags & US_FL_GO_SLOW)) - udelay(110); + udelay(125); if (transfer_length) { unsigned int pipe = srb->sc_data_direction == DMA_FROM_DEVICE ? diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h index d53f777c4f5..fa68dea6bc6 100644 --- a/drivers/usb/storage/unusual_devs.h +++ b/drivers/usb/storage/unusual_devs.h @@ -763,6 +763,19 @@ UNUSUAL_DEV( 0x07c4, 0xa109, 0x0000, 0xffff, US_FL_SINGLE_LUN ), #endif +#ifdef CONFIG_USB_STORAGE_DATAFAB +/* Reported by Felix Moeller <felix@derklecks.de> + * in Germany this is sold by Hama with the productnumber 46952 + * as "DualSlot CompactFlash(TM) & MStick Drive USB" + */ +UNUSUAL_DEV( 0x07c4, 0xa10b, 0x0000, 0xffff, + "DataFab Systems Inc.", + "USB CF+MS", + US_SC_SCSI, US_PR_DATAFAB, NULL, + 0 ), + +#endif + /* Datafab KECF-USB / Sagatek DCS-CF / Simpletech Flashlink UCF-100 * Only revision 1.13 tested (same for all of the above devices, * based on the Datafab DF-UG-07 chip). Needed for US_FL_FIX_INQUIRY. diff --git a/drivers/w1/w1.c b/drivers/w1/w1.c index fd630cec0e7..8d7821899cc 100644 --- a/drivers/w1/w1.c +++ b/drivers/w1/w1.c @@ -522,10 +522,11 @@ void w1_slave_found(unsigned long data, u64 rn) slave_count++; } - if (slave_count == dev->slave_count && rn ) { - tmp = cpu_to_le64(rn); - if(((rn >> 56) & 0xff) == w1_calc_crc8((u8 *)&tmp, 7)) - w1_attach_slave_device(dev, (struct w1_reg_num *) &rn); + rn = cpu_to_le64(rn); + + if (slave_count == dev->slave_count && + rn && ((le64_to_cpu(rn) >> 56) & 0xff) == w1_calc_crc8((u8 *)&rn, 7)) { + w1_attach_slave_device(dev, tmp); } atomic_dec(&dev->refcnt); diff --git a/drivers/w1/w1_smem.c b/drivers/w1/w1_smem.c index ab82eb7ed74..a54e425217a 100644 --- a/drivers/w1/w1_smem.c +++ b/drivers/w1/w1_smem.c @@ -60,7 +60,7 @@ static ssize_t w1_smem_read_val(struct device *dev, char *buf) int i; ssize_t count = 0; - for (i = 0; i < 9; ++i) + for (i = 0; i < 8; ++i) count += sprintf(buf + count, "%02x ", ((u8 *)&sl->reg_num)[i]); count += sprintf(buf + count, "\n"); @@ -87,7 +87,7 @@ static ssize_t w1_smem_read_bin(struct kobject *kobj, char *buf, loff_t off, siz count = 0; goto out; } - for (i = 0; i < 9; ++i) + for (i = 0; i < 8; ++i) count += sprintf(buf + count, "%02x ", ((u8 *)&sl->reg_num)[i]); count += sprintf(buf + count, "\n"); |