24 files changed, 192 insertions, 201 deletions

diff --git a/drivers/usb/atm/cxacru.c b/drivers/usb/atm/cxacru.c
index e6565633ba0f..3dfa3e40e148 100644
--- a/drivers/usb/atm/cxacru.c
+++ b/drivers/usb/atm/cxacru.c
@@ -158,7 +158,7 @@ struct cxacru_data {
         const struct cxacru_modem_type *modem_type;
 
         int line_status;
-        struct work_struct poll_work;
+        struct delayed_work poll_work;
 
         /* contol handles */
         struct mutex cm_serialize;
@@ -347,7 +347,7 @@ static int cxacru_card_status(struct cxacru_data *instance)
         return 0;
 }
 
-static void cxacru_poll_status(struct cxacru_data *instance);
+static void cxacru_poll_status(struct work_struct *work);
 
 static int cxacru_atm_start(struct usbatm_data *usbatm_instance,
                 struct atm_dev *atm_dev)
@@ -376,12 +376,14 @@ static int cxacru_atm_start(struct usbatm_data *usbatm_instance,
         }
 
         /* Start status polling */
-        cxacru_poll_status(instance);
+        cxacru_poll_status(&instance->poll_work.work);
         return 0;
 }
 
-static void cxacru_poll_status(struct cxacru_data *instance)
+static void cxacru_poll_status(struct work_struct *work)
 {
+        struct cxacru_data *instance =
+                container_of(work, struct cxacru_data, poll_work.work);
         u32 buf[CXINF_MAX] = {};
         struct usbatm_data *usbatm = instance->usbatm;
         struct atm_dev *atm_dev = usbatm->atm_dev;
@@ -720,7 +722,7 @@ static int cxacru_bind(struct usbatm_data *usbatm_instance,
 
         mutex_init(&instance->cm_serialize);
 
-        INIT_WORK(&instance->poll_work, (void *)cxacru_poll_status, instance);
+        INIT_DELAYED_WORK(&instance->poll_work, cxacru_poll_status);
 
         usbatm_instance->driver_data = instance;
 
diff --git a/drivers/usb/atm/speedtch.c b/drivers/usb/atm/speedtch.c
index a823486495c3..8ed6c75adf0f 100644
--- a/drivers/usb/atm/speedtch.c
+++ b/drivers/usb/atm/speedtch.c
@@ -142,7 +142,7 @@ struct speedtch_instance_data {
 
         struct speedtch_params params; /* set in probe, constant afterwards */
 
-        struct work_struct status_checker;
+        struct delayed_work status_checker;
 
         unsigned char last_status;
 
@@ -498,8 +498,11 @@ static int speedtch_start_synchro(struct speedtch_instance_data *instance)
         return ret;
 }
 
-static void speedtch_check_status(struct speedtch_instance_data *instance)
+static void speedtch_check_status(struct work_struct *work)
 {
+        struct speedtch_instance_data *instance =
+                container_of(work, struct speedtch_instance_data,
+                             status_checker.work);
         struct usbatm_data *usbatm = instance->usbatm;
         struct atm_dev *atm_dev = usbatm->atm_dev;
         unsigned char *buf = instance->scratch_buffer;
@@ -576,7 +579,7 @@ static void speedtch_status_poll(unsigned long data)
 {
         struct speedtch_instance_data *instance = (void *)data;
 
-        schedule_work(&instance->status_checker);
+        schedule_delayed_work(&instance->status_checker, 0);
 
         /* The following check is racy, but the race is harmless */
         if (instance->poll_delay < MAX_POLL_DELAY)
@@ -596,7 +599,7 @@ static void speedtch_resubmit_int(unsigned long data)
         if (int_urb) {
                 ret = usb_submit_urb(int_urb, GFP_ATOMIC);
                 if (!ret)
-                        schedule_work(&instance->status_checker);
+                        schedule_delayed_work(&instance->status_checker, 0);
                 else {
                         atm_dbg(instance->usbatm, "%s: usb_submit_urb failed with result %d\n", __func__, ret);
                         mod_timer(&instance->resubmit_timer, jiffies + msecs_to_jiffies(RESUBMIT_DELAY));
@@ -640,7 +643,7 @@ static void speedtch_handle_int(struct urb *int_urb)
 
         if ((int_urb = instance->int_urb)) {
                 ret = usb_submit_urb(int_urb, GFP_ATOMIC);
-                schedule_work(&instance->status_checker);
+                schedule_delayed_work(&instance->status_checker, 0);
                 if (ret < 0) {
                         atm_dbg(usbatm, "%s: usb_submit_urb failed with result %d\n", __func__, ret);
                         goto fail;
@@ -855,7 +858,7 @@ static int speedtch_bind(struct usbatm_data *usbatm,
 
         usbatm->flags |= (use_isoc ? UDSL_USE_ISOC : 0);
 
-        INIT_WORK(&instance->status_checker, (void *)speedtch_check_status, instance);
+        INIT_DELAYED_WORK(&instance->status_checker, speedtch_check_status);
 
         instance->status_checker.timer.function = speedtch_status_poll;
         instance->status_checker.timer.data = (unsigned long)instance;
diff --git a/drivers/usb/atm/ueagle-atm.c b/drivers/usb/atm/ueagle-atm.c
index c137c041f7a4..f2d196fa1e8b 100644
--- a/drivers/usb/atm/ueagle-atm.c
+++ b/drivers/usb/atm/ueagle-atm.c
@@ -655,9 +655,9 @@ static int request_dsp(struct uea_softc *sc)
 /*
  * The uea_load_page() function must be called within a process context
  */
-static void uea_load_page(void *xsc)
+static void uea_load_page(struct work_struct *work)
 {
-        struct uea_softc *sc = xsc;
+        struct uea_softc *sc = container_of(work, struct uea_softc, task);
         u16 pageno = sc->pageno;
         u16 ovl = sc->ovl;
         struct block_info bi;
@@ -1348,7 +1348,7 @@ static int uea_boot(struct uea_softc *sc)
 
         uea_enters(INS_TO_USBDEV(sc));
 
-        INIT_WORK(&sc->task, uea_load_page, sc);
+        INIT_WORK(&sc->task, uea_load_page);
         init_waitqueue_head(&sc->sync_q);
         init_waitqueue_head(&sc->cmv_ack_wait);
 
diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
index ec3438dc8ee5..7f1fa956dcdb 100644
--- a/drivers/usb/class/cdc-acm.c
+++ b/drivers/usb/class/cdc-acm.c
@@ -421,9 +421,9 @@ static void acm_write_bulk(struct urb *urb)
                 schedule_work(&acm->work);
 }
 
-static void acm_softint(void *private)
+static void acm_softint(struct work_struct *work)
 {
-        struct acm *acm = private;
+        struct acm *acm = container_of(work, struct acm, work);
         dbg("Entering acm_softint.");
         
         if (!ACM_READY(acm))
@@ -927,7 +927,7 @@ skip_normal_probe:
         acm->rx_buflimit = num_rx_buf;
         acm->urb_task.func = acm_rx_tasklet;
         acm->urb_task.data = (unsigned long) acm;
-        INIT_WORK(&acm->work, acm_softint, acm);
+        INIT_WORK(&acm->work, acm_softint);
         spin_lock_init(&acm->throttle_lock);
         spin_lock_init(&acm->write_lock);
         spin_lock_init(&acm->read_lock);
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index 0ce393eb3c4b..9be41ed1f9a6 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -68,7 +68,7 @@ struct usb_hub {
 
         unsigned                has_indicators:1;
         u8                      indicator[USB_MAXCHILDREN];
-        struct work_struct      leds;
+        struct delayed_work     leds;
 };
 
 
@@ -218,9 +218,10 @@ static void set_port_led(
 
 #define LED_CYCLE_PERIOD        ((2*HZ)/3)
 
-static void led_work (void *__hub)
+static void led_work (struct work_struct *work)
 {
-        struct usb_hub          *hub = __hub;
+        struct usb_hub          *hub =
+                container_of(work, struct usb_hub, leds.work);
         struct usb_device       *hdev = hub->hdev;
         unsigned                i;
         unsigned                changed = 0;
@@ -405,9 +406,10 @@ hub_clear_tt_buffer (struct usb_device *hdev, u16 devinfo, u16 tt)
  * talking to TTs must queue control transfers (not just bulk and iso), so
  * both can talk to the same hub concurrently.
  */
-static void hub_tt_kevent (void *arg)
+static void hub_tt_kevent (struct work_struct *work)
 {
-        struct usb_hub          *hub = arg;
+        struct usb_hub          *hub =
+                container_of(work, struct usb_hub, tt.kevent);
         unsigned long           flags;
 
         spin_lock_irqsave (&hub->tt.lock, flags);
@@ -694,7 +696,7 @@ static int hub_configure(struct usb_hub *hub,
 
         spin_lock_init (&hub->tt.lock);
         INIT_LIST_HEAD (&hub->tt.clear_list);
-        INIT_WORK (&hub->tt.kevent, hub_tt_kevent, hub);
+        INIT_WORK (&hub->tt.kevent, hub_tt_kevent);
         switch (hdev->descriptor.bDeviceProtocol) {
                 case 0:
                         break;
@@ -938,7 +940,7 @@ descriptor_error:
         INIT_LIST_HEAD(&hub->event_list);
         hub->intfdev = &intf->dev;
         hub->hdev = hdev;
-        INIT_WORK(&hub->leds, led_work, hub);
+        INIT_DELAYED_WORK(&hub->leds, led_work);
 
         usb_set_intfdata (intf, hub);
         intf->needs_remote_wakeup = 1;
@@ -2381,7 +2383,7 @@ check_highspeed (struct usb_hub *hub, struct usb_device *udev, int port1)
                 /* hub LEDs are probably harder to miss than syslog */
                 if (hub->has_indicators) {
                         hub->indicator[port1-1] = INDICATOR_GREEN_BLINK;
-                        schedule_work (&hub->leds);
+                        schedule_delayed_work (&hub->leds, 0);
                 }
         }
         kfree(qual);
@@ -2555,7 +2557,7 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
                                 if (hub->has_indicators) {
                                         hub->indicator[port1-1] =
                                                 INDICATOR_AMBER_BLINK;
-                                        schedule_work (&hub->leds);
+                                        schedule_delayed_work (&hub->leds, 0);
                                 }
                                 status = -ENOTCONN;     /* Don't retry */
                                 goto loop_disable;
diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c
index 29b0fa9ff9d0..7390b67c609d 100644
--- a/drivers/usb/core/message.c
+++ b/drivers/usb/core/message.c
@@ -1501,9 +1501,10 @@ struct set_config_request {
 };
 
 /* Worker routine for usb_driver_set_configuration() */
-static void driver_set_config_work(void *_req)
+static void driver_set_config_work(struct work_struct *work)
 {
-        struct set_config_request *req = _req;
+        struct set_config_request *req =
+                container_of(work, struct set_config_request, work);
 
         usb_lock_device(req->udev);
         usb_set_configuration(req->udev, req->config);
@@ -1541,7 +1542,7 @@ int usb_driver_set_configuration(struct usb_device *udev, int config)
                 return -ENOMEM;
         req->udev = udev;
         req->config = config;
-        INIT_WORK(&req->work, driver_set_config_work, req);
+        INIT_WORK(&req->work, driver_set_config_work);
 
         usb_get_dev(udev);
         if (!schedule_work(&req->work)) {
diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c
index 81cb52564e68..02426d0b9a34 100644
--- a/drivers/usb/core/usb.c
+++ b/drivers/usb/core/usb.c
@@ -203,9 +203,10 @@ static void ksuspend_usb_cleanup(void)
 #ifdef  CONFIG_USB_SUSPEND
 
 /* usb_autosuspend_work - callback routine to autosuspend a USB device */
-static void usb_autosuspend_work(void *_udev)
+static void usb_autosuspend_work(struct work_struct *work)
 {
-        struct usb_device       *udev = _udev;
+        struct usb_device *udev =
+                container_of(work, struct usb_device, autosuspend.work);
 
         usb_pm_lock(udev);
         udev->auto_pm = 1;
@@ -215,7 +216,7 @@ static void usb_autosuspend_work(void *_udev)
 
 #else
 
-static void usb_autosuspend_work(void *_udev)
+static void usb_autosuspend_work(struct work_struct *work)
 {}
 
 #endif  /* CONFIG_USB_SUSPEND */
@@ -304,7 +305,7 @@ usb_alloc_dev(struct usb_device *parent, struct usb_bus *bus, unsigned port1)
 
 #ifdef  CONFIG_PM
         mutex_init(&dev->pm_mutex);
-        INIT_WORK(&dev->autosuspend, usb_autosuspend_work, dev);
+        INIT_DELAYED_WORK(&dev->autosuspend, usb_autosuspend_work);
 #endif
         return dev;
 }
diff --git a/drivers/usb/gadget/ether.c b/drivers/usb/gadget/ether.c
index 3bd1dfe565c1..d15bf22b9a03 100644
--- a/drivers/usb/gadget/ether.c
+++ b/drivers/usb/gadget/ether.c
@@ -1833,9 +1833,9 @@ static void rx_fill (struct eth_dev *dev, gfp_t gfp_flags)
         spin_unlock_irqrestore(&dev->req_lock, flags);
 }
 
-static void eth_work (void *_dev)
+static void eth_work (struct work_struct *work)
 {
-        struct eth_dev          *dev = _dev;
+        struct eth_dev  *dev = container_of(work, struct eth_dev, work);
 
         if (test_and_clear_bit (WORK_RX_MEMORY, &dev->todo)) {
                 if (netif_running (dev->net))
@@ -2398,7 +2398,7 @@ autoconf_fail:
         dev = netdev_priv(net);
         spin_lock_init (&dev->lock);
         spin_lock_init (&dev->req_lock);
-        INIT_WORK (&dev->work, eth_work, dev);
+        INIT_WORK (&dev->work, eth_work);
         INIT_LIST_HEAD (&dev->tx_reqs);
         INIT_LIST_HEAD (&dev->rx_reqs);
 
diff --git a/drivers/usb/host/u132-hcd.c b/drivers/usb/host/u132-hcd.c
index ef54e310bfc4..a9d7119e3176 100644
--- a/drivers/usb/host/u132-hcd.c
+++ b/drivers/usb/host/u132-hcd.c
@@ -163,7 +163,7 @@ struct u132_endp {
         u16 queue_next;
         struct urb *urb_list[ENDP_QUEUE_SIZE];
         struct list_head urb_more;
-        struct work_struct scheduler;
+        struct delayed_work scheduler;
 };
 struct u132_ring {
         unsigned in_use:1;
@@ -171,7 +171,7 @@ struct u132_ring {
         u8 number;
         struct u132 *u132;
         struct u132_endp *curr_endp;
-        struct work_struct scheduler;
+        struct delayed_work scheduler;
 };
 #define OHCI_QUIRK_AMD756 0x01
 #define OHCI_QUIRK_SUPERIO 0x02
@@ -198,7 +198,7 @@ struct u132 {
         u32 hc_roothub_portstatus[MAX_ROOT_PORTS];
         int flags;
         unsigned long next_statechange;
-        struct work_struct monitor;
+        struct delayed_work monitor;
         int num_endpoints;
         struct u132_addr addr[MAX_U132_ADDRS];
         struct u132_udev udev[MAX_U132_UDEVS];
@@ -310,7 +310,7 @@ static void u132_ring_requeue_work(struct u132 *u132, struct u132_ring *ring,
         if (delta > 0) {
                 if (queue_delayed_work(workqueue, &ring->scheduler, delta))
                         return;
-        } else if (queue_work(workqueue, &ring->scheduler))
+        } else if (queue_delayed_work(workqueue, &ring->scheduler, 0))
                 return;
         kref_put(&u132->kref, u132_hcd_delete);
         return;
@@ -389,12 +389,8 @@ static inline void u132_endp_init_kref(struct u132 *u132,
 static void u132_endp_queue_work(struct u132 *u132, struct u132_endp *endp,
         unsigned int delta)
 {
-        if (delta > 0) {
-                if (queue_delayed_work(workqueue, &endp->scheduler, delta))
-                        kref_get(&endp->kref);
-        } else if (queue_work(workqueue, &endp->scheduler))
-                kref_get(&endp->kref);
-        return;
+        if (queue_delayed_work(workqueue, &endp->scheduler, delta))
+                kref_get(&endp->kref);
 }
 
 static void u132_endp_cancel_work(struct u132 *u132, struct u132_endp *endp)
@@ -410,24 +406,14 @@ static inline void u132_monitor_put_kref(struct u132 *u132)
 
 static void u132_monitor_queue_work(struct u132 *u132, unsigned int delta)
 {
-        if (delta > 0) {
-                if (queue_delayed_work(workqueue, &u132->monitor, delta)) {
-                        kref_get(&u132->kref);
-                }
-        } else if (queue_work(workqueue, &u132->monitor))
-                kref_get(&u132->kref);
-        return;
+        if (queue_delayed_work(workqueue, &u132->monitor, delta))
+                kref_get(&u132->kref);
 }
 
 static void u132_monitor_requeue_work(struct u132 *u132, unsigned int delta)
 {
-        if (delta > 0) {
-                if (queue_delayed_work(workqueue, &u132->monitor, delta))
-                        return;
-        } else if (queue_work(workqueue, &u132->monitor))
-                return;
-        kref_put(&u132->kref, u132_hcd_delete);
-        return;
+        if (!queue_delayed_work(workqueue, &u132->monitor, delta))
+                kref_put(&u132->kref, u132_hcd_delete);
 }
 
 static void u132_monitor_cancel_work(struct u132 *u132)
@@ -489,9 +475,9 @@ static int read_roothub_info(struct u132 *u132)
         return 0;
 }
 
-static void u132_hcd_monitor_work(void *data)
+static void u132_hcd_monitor_work(struct work_struct *work)
 {
-        struct u132 *u132 = data;
+        struct u132 *u132 = container_of(work, struct u132, monitor.work);
         if (u132->going > 1) {
                 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
                         , u132->going);
@@ -1315,15 +1301,14 @@ static void u132_hcd_initial_setup_sent(void *data, struct urb *urb, u8 *buf,
         }
 }
 
-static void u132_hcd_ring_work_scheduler(void *data);
-static void u132_hcd_endp_work_scheduler(void *data);
 /*
 * this work function is only executed from the work queue
 *
 */
-static void u132_hcd_ring_work_scheduler(void *data)
+static void u132_hcd_ring_work_scheduler(struct work_struct *work)
 {
-        struct u132_ring *ring = data;
+        struct u132_ring *ring =
+                container_of(work, struct u132_ring, scheduler.work);
         struct u132 *u132 = ring->u132;
         down(&u132->scheduler_lock);
         if (ring->in_use) {
@@ -1382,10 +1367,11 @@ static void u132_hcd_ring_work_scheduler(void *data)
         }
 }
 
-static void u132_hcd_endp_work_scheduler(void *data)
+static void u132_hcd_endp_work_scheduler(struct work_struct *work)
 {
         struct u132_ring *ring;
-        struct u132_endp *endp = data;
+        struct u132_endp *endp =
+                container_of(work, struct u132_endp, scheduler.work);
         struct u132 *u132 = endp->u132;
         down(&u132->scheduler_lock);
         ring = endp->ring;
@@ -1943,7 +1929,7 @@ static int create_endpoint_and_queue_int(struct u132 *u132,
         if (!endp) {
                 return -ENOMEM;
         }
-        INIT_WORK(&endp->scheduler, u132_hcd_endp_work_scheduler, (void *)endp);
+        INIT_DELAYED_WORK(&endp->scheduler, u132_hcd_endp_work_scheduler);
         spin_lock_init(&endp->queue_lock.slock);
         INIT_LIST_HEAD(&endp->urb_more);
         ring = endp->ring = &u132->ring[0];
@@ -2032,7 +2018,7 @@ static int create_endpoint_and_queue_bulk(struct u132 *u132,
         if (!endp) {
                 return -ENOMEM;
         }
-        INIT_WORK(&endp->scheduler, u132_hcd_endp_work_scheduler, (void *)endp);
+        INIT_DELAYED_WORK(&endp->scheduler, u132_hcd_endp_work_scheduler);
         spin_lock_init(&endp->queue_lock.slock);
         INIT_LIST_HEAD(&endp->urb_more);
         endp->dequeueing = 0;
@@ -2117,7 +2103,7 @@ static int create_endpoint_and_queue_control(struct u132 *u132,
         if (!endp) {
                 return -ENOMEM;
         }
-        INIT_WORK(&endp->scheduler, u132_hcd_endp_work_scheduler, (void *)endp);
+        INIT_DELAYED_WORK(&endp->scheduler, u132_hcd_endp_work_scheduler);
         spin_lock_init(&endp->queue_lock.slock);
         INIT_LIST_HEAD(&endp->urb_more);
         ring = endp->ring = &u132->ring[0];
@@ -3096,10 +3082,10 @@ static void u132_initialise(struct u132 *u132, struct platform_device *pdev)
                 ring->number = rings + 1;
                 ring->length = 0;
                 ring->curr_endp = NULL;
-                INIT_WORK(&ring->scheduler, u132_hcd_ring_work_scheduler,
-                        (void *)ring);
+                INIT_DELAYED_WORK(&ring->scheduler,
+                                  u132_hcd_ring_work_scheduler);
         } down(&u132->sw_lock);
-        INIT_WORK(&u132->monitor, u132_hcd_monitor_work, (void *)u132);
+        INIT_DELAYED_WORK(&u132->monitor, u132_hcd_monitor_work);
         while (ports-- > 0) {
                 struct u132_port *port = &u132->port[ports];
                 port->u132 = u132;
diff --git a/drivers/usb/input/hid-core.c b/drivers/usb/input/hid-core.c
index a49644b7c58e..4295bab4f1e2 100644
--- a/drivers/usb/input/hid-core.c
+++ b/drivers/usb/input/hid-core.c
@@ -969,9 +969,10 @@ static void hid_retry_timeout(unsigned long _hid)
 }
 
 /* Workqueue routine to reset the device or clear a halt */
-static void hid_reset(void *_hid)
+static void hid_reset(struct work_struct *work)
 {
-        struct hid_device *hid = (struct hid_device *) _hid;
+        struct hid_device *hid =
+                container_of(work, struct hid_device, reset_work);
         int rc_lock, rc = 0;
 
         if (test_bit(HID_CLEAR_HALT, &hid->iofl)) {
@@ -2043,7 +2044,7 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
 
         init_waitqueue_head(&hid->wait);
 
-        INIT_WORK(&hid->reset_work, hid_reset, hid);
+        INIT_WORK(&hid->reset_work, hid_reset);
         setup_timer(&hid->io_retry, hid_retry_timeout, (unsigned long) hid);
 
         spin_lock_init(&hid->inlock);
diff --git a/drivers/usb/misc/appledisplay.c b/drivers/usb/misc/appledisplay.c
index ba30ca6a14aa..02cbb7fff24f 100644
--- a/drivers/usb/misc/appledisplay.c
+++ b/drivers/usb/misc/appledisplay.c
@@ -76,7 +76,7 @@ struct appledisplay {
         char *urbdata;                  /* interrupt URB data buffer */
         char *msgdata;                  /* control message data buffer */
 
-        struct work_struct work;
+        struct delayed_work work;
         int button_pressed;
         spinlock_t lock;
 };
@@ -117,7 +117,7 @@ static void appledisplay_complete(struct urb *urb)
         case ACD_BTN_BRIGHT_UP:
         case ACD_BTN_BRIGHT_DOWN:
                 pdata->button_pressed = 1;
-                queue_work(wq, &pdata->work);
+                queue_delayed_work(wq, &pdata->work, 0);
                 break;
         case ACD_BTN_NONE:
         default:
@@ -184,9 +184,10 @@ static struct backlight_properties appledisplay_bl_data = {
         .max_brightness = 0xFF
 };
 
-static void appledisplay_work(void *private)
+static void appledisplay_work(struct work_struct *work)
 {
-        struct appledisplay *pdata = private;
+        struct appledisplay *pdata =
+                container_of(work, struct appledisplay, work.work);
         int retval;
 
         up(&pdata->bd->sem);
@@ -238,7 +239,7 @@ static int appledisplay_probe(struct usb_interface *iface,
         pdata->udev = udev;
 
         spin_lock_init(&pdata->lock);
-        INIT_WORK(&pdata->work, appledisplay_work, pdata);
+        INIT_DELAYED_WORK(&pdata->work, appledisplay_work);
 
         /* Allocate buffer for control messages */
         pdata->msgdata = kmalloc(ACD_MSG_BUFFER_LEN, GFP_KERNEL);
diff --git a/drivers/usb/misc/ftdi-elan.c b/drivers/usb/misc/ftdi-elan.c
index cb0ba3107d7f..18b1925032a8 100644
--- a/drivers/usb/misc/ftdi-elan.c
+++ b/drivers/usb/misc/ftdi-elan.c
@@ -156,9 +156,9 @@ struct usb_ftdi {
         struct usb_device *udev;
         struct usb_interface *interface;
         struct usb_class_driver *class;
-        struct work_struct status_work;
-        struct work_struct command_work;
-        struct work_struct respond_work;
+        struct delayed_work status_work;
+        struct delayed_work command_work;
+        struct delayed_work respond_work;
         struct u132_platform_data platform_data;
         struct resource resources[0];
         struct platform_device platform_dev;
@@ -210,23 +210,14 @@ static void ftdi_elan_init_kref(struct usb_ftdi *ftdi)
 
 static void ftdi_status_requeue_work(struct usb_ftdi *ftdi, unsigned int delta)
 {
-        if (delta > 0) {
-                if (queue_delayed_work(status_queue, &ftdi->status_work, delta))
-                        return;
-        } else if (queue_work(status_queue, &ftdi->status_work))
-                return;
-        kref_put(&ftdi->kref, ftdi_elan_delete);
-        return;
+        if (!queue_delayed_work(status_queue, &ftdi->status_work, delta))
+                kref_put(&ftdi->kref, ftdi_elan_delete);
 }
 
 static void ftdi_status_queue_work(struct usb_ftdi *ftdi, unsigned int delta)
 {
-        if (delta > 0) {
-                if (queue_delayed_work(status_queue, &ftdi->status_work, delta))
-                        kref_get(&ftdi->kref);
-        } else if (queue_work(status_queue, &ftdi->status_work))
-                kref_get(&ftdi->kref);
-        return;
+        if (queue_delayed_work(status_queue, &ftdi->status_work, delta))
+                kref_get(&ftdi->kref);
 }
 
 static void ftdi_status_cancel_work(struct usb_ftdi *ftdi)
@@ -237,25 +228,14 @@ static void ftdi_status_cancel_work(struct usb_ftdi *ftdi)
 
 static void ftdi_command_requeue_work(struct usb_ftdi *ftdi, unsigned int delta)
 {
-        if (delta > 0) {
-                if (queue_delayed_work(command_queue, &ftdi->command_work,
-                        delta))
-                        return;
-        } else if (queue_work(command_queue, &ftdi->command_work))
-                return;
-        kref_put(&ftdi->kref, ftdi_elan_delete);
-        return;
+        if (!queue_delayed_work(command_queue, &ftdi->command_work, delta))
+                kref_put(&ftdi->kref, ftdi_elan_delete);
 }
 
 static void ftdi_command_queue_work(struct usb_ftdi *ftdi, unsigned int delta)
 {
-        if (delta > 0) {
-                if (queue_delayed_work(command_queue, &ftdi->command_work,
-                        delta))
-                        kref_get(&ftdi->kref);
-        } else if (queue_work(command_queue, &ftdi->command_work))
-                kref_get(&ftdi->kref);
-        return;
+        if (queue_delayed_work(command_queue, &ftdi->command_work, delta))
+                kref_get(&ftdi->kref);
 }
 
 static void ftdi_command_cancel_work(struct usb_ftdi *ftdi)
@@ -267,25 +247,14 @@ static void ftdi_command_cancel_work(struct usb_ftdi *ftdi)
 static void ftdi_response_requeue_work(struct usb_ftdi *ftdi,
         unsigned int delta)
 {
-        if (delta > 0) {
-                if (queue_delayed_work(respond_queue, &ftdi->respond_work,
-                        delta))
-                        return;
-        } else if (queue_work(respond_queue, &ftdi->respond_work))
-                return;
-        kref_put(&ftdi->kref, ftdi_elan_delete);
-        return;
+        if (!queue_delayed_work(respond_queue, &ftdi->respond_work, delta))
+                kref_put(&ftdi->kref, ftdi_elan_delete);
 }
 
 static void ftdi_respond_queue_work(struct usb_ftdi *ftdi, unsigned int delta)
 {
-        if (delta > 0) {
-                if (queue_delayed_work(respond_queue, &ftdi->respond_work,
-                        delta))
-                        kref_get(&ftdi->kref);
-        } else if (queue_work(respond_queue, &ftdi->respond_work))
-                kref_get(&ftdi->kref);
-        return;
+        if (queue_delayed_work(respond_queue, &ftdi->respond_work, delta))
+                kref_get(&ftdi->kref);
 }
 
 static void ftdi_response_cancel_work(struct usb_ftdi *ftdi)
@@ -475,9 +444,11 @@ static void ftdi_elan_kick_command_queue(struct usb_ftdi *ftdi)
         return;
 }
 
-static void ftdi_elan_command_work(void *data)
+static void ftdi_elan_command_work(struct work_struct *work)
 {
-        struct usb_ftdi *ftdi = data;
+        struct usb_ftdi *ftdi =
+                container_of(work, struct usb_ftdi, command_work.work);
+
         if (ftdi->disconnected > 0) {
                 ftdi_elan_put_kref(ftdi);
                 return;
@@ -500,9 +471,10 @@ static void ftdi_elan_kick_respond_queue(struct usb_ftdi *ftdi)
         return;
 }
 
-static void ftdi_elan_respond_work(void *data)
+static void ftdi_elan_respond_work(struct work_struct *work)
 {
-        struct usb_ftdi *ftdi = data;
+        struct usb_ftdi *ftdi =
+                container_of(work, struct usb_ftdi, respond_work.work);
         if (ftdi->disconnected > 0) {
                 ftdi_elan_put_kref(ftdi);
                 return;
@@ -534,9 +506,10 @@ static void ftdi_elan_respond_work(void *data)
 * after the FTDI has been synchronized
 *
 */
-static void ftdi_elan_status_work(void *data)
+static void ftdi_elan_status_work(struct work_struct *work)
 {
-        struct usb_ftdi *ftdi = data;
+        struct usb_ftdi *ftdi =
+                container_of(work, struct usb_ftdi, status_work.work);
         int work_delay_in_msec = 0;
         if (ftdi->disconnected > 0) {
                 ftdi_elan_put_kref(ftdi);
@@ -2677,12 +2650,9 @@ static int ftdi_elan_probe(struct usb_interface *interface,
                 ftdi->class = NULL;
                 dev_info(&ftdi->udev->dev, "USB FDTI=%p ELAN interface %d now a"
                         "ctivated\n", ftdi, iface_desc->desc.bInterfaceNumber);
-                INIT_WORK(&ftdi->status_work, ftdi_elan_status_work,
-                        (void *)ftdi);
-                INIT_WORK(&ftdi->command_work, ftdi_elan_command_work,
-                        (void *)ftdi);
-                INIT_WORK(&ftdi->respond_work, ftdi_elan_respond_work,
-                        (void *)ftdi);
+                INIT_DELAYED_WORK(&ftdi->status_work, ftdi_elan_status_work);
+                INIT_DELAYED_WORK(&ftdi->command_work, ftdi_elan_command_work);
+                INIT_DELAYED_WORK(&ftdi->respond_work, ftdi_elan_respond_work);
                 ftdi_status_queue_work(ftdi, msecs_to_jiffies(3 *1000));
                 return 0;
         } else {
diff --git a/drivers/usb/misc/phidgetkit.c b/drivers/usb/misc/phidgetkit.c
index 9110793f81d3..9659c79e187e 100644
--- a/drivers/usb/misc/phidgetkit.c
+++ b/drivers/usb/misc/phidgetkit.c
@@ -81,8 +81,8 @@ struct interfacekit {
         unsigned char *data;
         dma_addr_t data_dma;
 
-        struct work_struct do_notify;
-        struct work_struct do_resubmit;
+        struct delayed_work do_notify;
+        struct delayed_work do_resubmit;
         unsigned long input_events;
         unsigned long sensor_events;
 };
@@ -374,7 +374,7 @@ static void interfacekit_irq(struct urb *urb)
         }
 
         if (kit->input_events || kit->sensor_events)
-                schedule_work(&kit->do_notify);
+                schedule_delayed_work(&kit->do_notify, 0);
 
 resubmit:
         status = usb_submit_urb(urb, SLAB_ATOMIC);
@@ -384,9 +384,10 @@ resubmit:
                         kit->udev->devpath, status);
 }
 
-static void do_notify(void *data)
+static void do_notify(struct work_struct *work)
 {
-        struct interfacekit *kit = data;
+        struct interfacekit *kit =
+                container_of(work, struct interfacekit, do_notify.work);
         int i;
         char sysfs_file[8];
 
@@ -405,9 +406,11 @@ static void do_notify(void *data)
         }
 }
 
-static void do_resubmit(void *data)
+static void do_resubmit(struct work_struct *work)
 {
-        set_outputs(data);
+        struct interfacekit *kit =
+                container_of(work, struct interfacekit, do_resubmit.work);
+        set_outputs(kit);
 }
 
 #define show_set_output(value)          \
@@ -575,8 +578,8 @@ static int interfacekit_probe(struct usb_interface *intf, const struct usb_devic
 
         kit->udev = usb_get_dev(dev);
         kit->intf = intf;
-        INIT_WORK(&kit->do_notify, do_notify, kit);
-        INIT_WORK(&kit->do_resubmit, do_resubmit, kit);
+        INIT_DELAYED_WORK(&kit->do_notify, do_notify);
+        INIT_DELAYED_WORK(&kit->do_resubmit, do_resubmit);
         usb_fill_int_urb(kit->irq, kit->udev, pipe, kit->data,
                         maxp > URB_INT_SIZE ? URB_INT_SIZE : maxp,
                         interfacekit_irq, kit, endpoint->bInterval);
diff --git a/drivers/usb/misc/phidgetmotorcontrol.c b/drivers/usb/misc/phidgetmotorcontrol.c
index c3469b0a67c2..2bb4fa572bb7 100644
--- a/drivers/usb/misc/phidgetmotorcontrol.c
+++ b/drivers/usb/misc/phidgetmotorcontrol.c
@@ -41,7 +41,7 @@ struct motorcontrol {
         unsigned char *data;
         dma_addr_t data_dma;
 
-        struct work_struct do_notify;
+        struct delayed_work do_notify;
         unsigned long input_events;
         unsigned long speed_events;
         unsigned long exceed_events;
@@ -148,7 +148,7 @@ static void motorcontrol_irq(struct urb *urb)
                 set_bit(1, &mc->exceed_events);
 
         if (mc->input_events || mc->exceed_events || mc->speed_events)
-                schedule_work(&mc->do_notify);
+                schedule_delayed_work(&mc->do_notify, 0);
 
 resubmit:
         status = usb_submit_urb(urb, SLAB_ATOMIC);
@@ -159,9 +159,10 @@ resubmit:
                         mc->udev->devpath, status);
 }
 
-static void do_notify(void *data)
+static void do_notify(struct work_struct *work)
 {
-        struct motorcontrol *mc = data;
+        struct motorcontrol *mc =
+                container_of(work, struct motorcontrol, do_notify.work);
         int i;
         char sysfs_file[8];
 
@@ -348,7 +349,7 @@ static int motorcontrol_probe(struct usb_interface *intf, const struct usb_devic
         mc->udev = usb_get_dev(dev);
         mc->intf = intf;
         mc->acceleration[0] = mc->acceleration[1] = 10;
-        INIT_WORK(&mc->do_notify, do_notify, mc);
+        INIT_DELAYED_WORK(&mc->do_notify, do_notify);
         usb_fill_int_urb(mc->irq, mc->udev, pipe, mc->data,
                         maxp > URB_INT_SIZE ? URB_INT_SIZE : maxp,
                         motorcontrol_irq, mc, endpoint->bInterval);
diff --git a/drivers/usb/net/kaweth.c b/drivers/usb/net/kaweth.c
index 7c906a43e497..fa78326d0bf0 100644
--- a/drivers/usb/net/kaweth.c
+++ b/drivers/usb/net/kaweth.c
@@ -222,7 +222,7 @@ struct kaweth_device
         int suspend_lowmem_ctrl;
         int linkstate;
         int opened;
-        struct work_struct lowmem_work;
+        struct delayed_work lowmem_work;
 
         struct usb_device *dev;
         struct net_device *net;
@@ -530,9 +530,10 @@ resubmit:
         kaweth_resubmit_int_urb(kaweth, GFP_ATOMIC);
 }
 
-static void kaweth_resubmit_tl(void *d)
+static void kaweth_resubmit_tl(struct work_struct *work)
 {
-        struct kaweth_device *kaweth = (struct kaweth_device *)d;
+        struct kaweth_device *kaweth =
+                container_of(work, struct kaweth_device, lowmem_work.work);
 
         if (IS_BLOCKED(kaweth->status))
                 return;
@@ -1126,7 +1127,7 @@ err_fw:
 
         /* kaweth is zeroed as part of alloc_netdev */
 
-        INIT_WORK(&kaweth->lowmem_work, kaweth_resubmit_tl, (void *)kaweth);
+        INIT_DELAYED_WORK(&kaweth->lowmem_work, kaweth_resubmit_tl);
 
         SET_MODULE_OWNER(netdev);
 
diff --git a/drivers/usb/net/pegasus.c b/drivers/usb/net/pegasus.c
index 69eb0db399df..b5690b3834e3 100644
--- a/drivers/usb/net/pegasus.c
+++ b/drivers/usb/net/pegasus.c
@@ -1281,9 +1281,9 @@ static inline void setup_pegasus_II(pegasus_t * pegasus)
 static struct workqueue_struct *pegasus_workqueue = NULL;
 #define CARRIER_CHECK_DELAY (2 * HZ)
 
-static void check_carrier(void *data)
+static void check_carrier(struct work_struct *work)
 {
-        pegasus_t *pegasus = data;
+        pegasus_t *pegasus = container_of(work, pegasus_t, carrier_check.work);
         set_carrier(pegasus->net);
         if (!(pegasus->flags & PEGASUS_UNPLUG)) {
                 queue_delayed_work(pegasus_workqueue, &pegasus->carrier_check,
@@ -1319,7 +1319,7 @@ static int pegasus_probe(struct usb_interface *intf,
 
         tasklet_init(&pegasus->rx_tl, rx_fixup, (unsigned long) pegasus);
 
-        INIT_WORK(&pegasus->carrier_check, check_carrier, pegasus);
+        INIT_DELAYED_WORK(&pegasus->carrier_check, check_carrier);
 
         pegasus->intf = intf;
         pegasus->usb = dev;
diff --git a/drivers/usb/net/pegasus.h b/drivers/usb/net/pegasus.h
index 006438069b66..98f6898cae1f 100644
--- a/drivers/usb/net/pegasus.h
+++ b/drivers/usb/net/pegasus.h
@@ -95,7 +95,7 @@ typedef struct pegasus {
         int                     dev_index;
         int                     intr_interval;
         struct tasklet_struct   rx_tl;
-        struct work_struct      carrier_check;
+        struct delayed_work     carrier_check;
         struct urb              *ctrl_urb, *rx_urb, *tx_urb, *intr_urb;
         struct sk_buff          *rx_pool[RX_SKBS];
         struct sk_buff          *rx_skb;
diff --git a/drivers/usb/net/usbnet.c b/drivers/usb/net/usbnet.c
index 7672e11c94c4..327f97555679 100644
--- a/drivers/usb/net/usbnet.c
+++ b/drivers/usb/net/usbnet.c
@@ -782,9 +782,10 @@ static struct ethtool_ops usbnet_ethtool_ops = {
  * especially now that control transfers can be queued.
  */
 static void
-kevent (void *data)
+kevent (struct work_struct *work)
 {
-        struct usbnet           *dev = data;
+        struct usbnet           *dev =
+                container_of(work, struct usbnet, kevent);
         int                     status;
 
         /* usb_clear_halt() needs a thread context */
@@ -1146,7 +1147,7 @@ usbnet_probe (struct usb_interface *udev, const struct usb_device_id *prod)
         skb_queue_head_init (&dev->done);
         dev->bh.func = usbnet_bh;
         dev->bh.data = (unsigned long) dev;
-        INIT_WORK (&dev->kevent, kevent, dev);
+        INIT_WORK (&dev->kevent, kevent);
         dev->delay.function = usbnet_bh;
         dev->delay.data = (unsigned long) dev;
         init_timer (&dev->delay);
diff --git a/drivers/usb/serial/aircable.c b/drivers/usb/serial/aircable.c
index b1b5707bc99a..86bcf63b6ba5 100644
--- a/drivers/usb/serial/aircable.c
+++ b/drivers/usb/serial/aircable.c
@@ -92,6 +92,7 @@ struct aircable_private {
         struct circ_buf *rx_buf;        /* read buffer */
         int rx_flags;                   /* for throttilng */
         struct work_struct rx_work;     /* work cue for the receiving line */
+        struct usb_serial_port *port;   /* USB port with which associated */
 };
 
 /* Private methods */
@@ -251,10 +252,11 @@ static void aircable_send(struct usb_serial_port *port)
         schedule_work(&port->work);
 }
 
-static void aircable_read(void *params)
+static void aircable_read(struct work_struct *work)
 {
-        struct usb_serial_port *port = params;
-        struct aircable_private *priv = usb_get_serial_port_data(port);
+        struct aircable_private *priv =
+                container_of(work, struct aircable_private, rx_work);
+        struct usb_serial_port *port = priv->port;
         struct tty_struct *tty;
         unsigned char *data;
         int count;
@@ -349,7 +351,8 @@ static int aircable_attach (struct usb_serial *serial)
         }
 
         priv->rx_flags &= ~(THROTTLED | ACTUALLY_THROTTLED);
-        INIT_WORK(&priv->rx_work, aircable_read, port);
+        priv->port = port;
+        INIT_WORK(&priv->rx_work, aircable_read);
 
         usb_set_serial_port_data(serial->port[0], priv);
 
@@ -516,7 +519,7 @@ static void aircable_read_bulk_callback(struct urb *urb)
                                         package_length - shift);
                         }
                 }
-                aircable_read(port);
+                aircable_read(&priv->rx_work);
         }
 
         /* Schedule the next read _if_ we are still open */
diff --git a/drivers/usb/serial/digi_acceleport.c b/drivers/usb/serial/digi_acceleport.c
index 5e3ac281a2f8..83d0e21145b0 100644
--- a/drivers/usb/serial/digi_acceleport.c
+++ b/drivers/usb/serial/digi_acceleport.c
@@ -430,13 +430,14 @@ struct digi_port {
         int dp_in_close;                        /* close in progress */
         wait_queue_head_t dp_close_wait;        /* wait queue for close */
         struct work_struct dp_wakeup_work;
+        struct usb_serial_port *dp_port;
 };
 
 
 /* Local Function Declarations */
 
 static void digi_wakeup_write( struct usb_serial_port *port );
-static void digi_wakeup_write_lock(void *);
+static void digi_wakeup_write_lock(struct work_struct *work);
 static int digi_write_oob_command( struct usb_serial_port *port,
         unsigned char *buf, int count, int interruptible );
 static int digi_write_inb_command( struct usb_serial_port *port,
@@ -598,11 +599,12 @@ static inline long cond_wait_interruptible_timeout_irqrestore(
 *  on writes.
 */
 
-static void digi_wakeup_write_lock(void *arg)
+static void digi_wakeup_write_lock(struct work_struct *work)
 {
-        struct usb_serial_port *port = arg;
+        struct digi_port *priv =
+                container_of(work, struct digi_port, dp_wakeup_work);
+        struct usb_serial_port *port = priv->dp_port;
         unsigned long flags;
-        struct digi_port *priv = usb_get_serial_port_data(port);
 
 
         spin_lock_irqsave( &priv->dp_port_lock, flags );
@@ -1702,8 +1704,8 @@ dbg( "digi_startup: TOP" );
                 init_waitqueue_head( &priv->dp_flush_wait );
                 priv->dp_in_close = 0;
                 init_waitqueue_head( &priv->dp_close_wait );
-                INIT_WORK(&priv->dp_wakeup_work,
-                                digi_wakeup_write_lock, serial->port[i]);
+                INIT_WORK(&priv->dp_wakeup_work, digi_wakeup_write_lock);
+                priv->dp_port = serial->port[i];
 
                 /* initialize write wait queue for this port */
                 init_waitqueue_head( &serial->port[i]->write_wait );
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index 89ce2775be15..72e4d48f51e9 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -559,7 +559,8 @@ struct ftdi_private {
         char prev_status, diff_status;        /* Used for TIOCMIWAIT */
         __u8 rx_flags;          /* receive state flags (throttling) */
         spinlock_t rx_lock;     /* spinlock for receive state */
-        struct work_struct rx_work;
+        struct delayed_work rx_work;
+        struct usb_serial_port *port;
         int rx_processed;
         unsigned long rx_bytes;
 
@@ -593,7 +594,7 @@ static int  ftdi_write_room		(struct usb_serial_port *port);
 static int  ftdi_chars_in_buffer        (struct usb_serial_port *port);
 static void ftdi_write_bulk_callback    (struct urb *urb);
 static void ftdi_read_bulk_callback     (struct urb *urb);
-static void ftdi_process_read           (void *param);
+static void ftdi_process_read           (struct work_struct *work);
 static void ftdi_set_termios            (struct usb_serial_port *port, struct termios * old);
 static int  ftdi_tiocmget               (struct usb_serial_port *port, struct file *file);
 static int  ftdi_tiocmset               (struct usb_serial_port *port, struct file * file, unsigned int set, unsigned int clear);
@@ -1201,7 +1202,8 @@ static int ftdi_sio_attach (struct usb_serial *serial)
                 port->read_urb->transfer_buffer_length = BUFSZ;
         }
 
-        INIT_WORK(&priv->rx_work, ftdi_process_read, port);
+        INIT_DELAYED_WORK(&priv->rx_work, ftdi_process_read);
+        priv->port = port;
 
         /* Free port's existing write urb and transfer buffer. */
         if (port->write_urb) {
@@ -1640,17 +1642,18 @@ static void ftdi_read_bulk_callback (struct urb *urb)
         priv->rx_bytes += countread;
         spin_unlock_irqrestore(&priv->rx_lock, flags);
 
-        ftdi_process_read(port);
+        ftdi_process_read(&priv->rx_work.work);
 
 } /* ftdi_read_bulk_callback */
 
 
-static void ftdi_process_read (void *param)
+static void ftdi_process_read (struct work_struct *work)
 { /* ftdi_process_read */
-        struct usb_serial_port *port = (struct usb_serial_port*)param;
+        struct ftdi_private *priv =
+                container_of(work, struct ftdi_private, rx_work.work);
+        struct usb_serial_port *port = priv->port;
         struct urb *urb;
         struct tty_struct *tty;
-        struct ftdi_private *priv;
         char error_flag;
         unsigned char *data;
 
@@ -2179,7 +2182,7 @@ static void ftdi_unthrottle (struct usb_serial_port *port)
         spin_unlock_irqrestore(&priv->rx_lock, flags);
 
         if (actually_throttled)
-                schedule_work(&priv->rx_work);
+                schedule_delayed_work(&priv->rx_work, 0);
 }
 
 static int __init ftdi_init (void)
diff --git a/drivers/usb/serial/keyspan_pda.c b/drivers/usb/serial/keyspan_pda.c
index 909005107ea2..e09a0bfe6231 100644
--- a/drivers/usb/serial/keyspan_pda.c
+++ b/drivers/usb/serial/keyspan_pda.c
@@ -120,6 +120,8 @@ struct keyspan_pda_private {
         int                     tx_throttled;
         struct work_struct                      wakeup_work;
         struct work_struct                      unthrottle_work;
+        struct usb_serial       *serial;
+        struct usb_serial_port  *port;
 };
 
 
@@ -175,9 +177,11 @@ static struct usb_device_id id_table_fake_xircom [] = {
 };
 #endif
 
-static void keyspan_pda_wakeup_write( struct usb_serial_port *port )
+static void keyspan_pda_wakeup_write(struct work_struct *work)
 {
-
+        struct keyspan_pda_private *priv =
+                container_of(work, struct keyspan_pda_private, wakeup_work);
+        struct usb_serial_port *port = priv->port;
         struct tty_struct *tty = port->tty;
 
         /* wake up port processes */
@@ -187,8 +191,11 @@ static void keyspan_pda_wakeup_write( struct usb_serial_port *port )
         tty_wakeup(tty);
 }
 
-static void keyspan_pda_request_unthrottle( struct usb_serial *serial )
+static void keyspan_pda_request_unthrottle(struct work_struct *work)
 {
+        struct keyspan_pda_private *priv =
+                container_of(work, struct keyspan_pda_private, unthrottle_work);
+        struct usb_serial *serial = priv->serial;
         int result;
 
         dbg(" request_unthrottle");
@@ -765,11 +772,10 @@ static int keyspan_pda_startup (struct usb_serial *serial)
                 return (1); /* error */
         usb_set_serial_port_data(serial->port[0], priv);
         init_waitqueue_head(&serial->port[0]->write_wait);
-        INIT_WORK(&priv->wakeup_work, (void *)keyspan_pda_wakeup_write,
-                        (void *)(serial->port[0]));
-        INIT_WORK(&priv->unthrottle_work,
-                        (void *)keyspan_pda_request_unthrottle,
-                        (void *)(serial));
+        INIT_WORK(&priv->wakeup_work, keyspan_pda_wakeup_write);
+        INIT_WORK(&priv->unthrottle_work, keyspan_pda_request_unthrottle);
+        priv->serial = serial;
+        priv->port = serial->port[0];
         return (0);
 }
 
diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c
index c1257d5292f5..3d5072f14b8d 100644
--- a/drivers/usb/serial/usb-serial.c
+++ b/drivers/usb/serial/usb-serial.c
@@ -533,9 +533,10 @@ void usb_serial_port_softint(struct usb_serial_port *port)
         schedule_work(&port->work);
 }
 
-static void usb_serial_port_work(void *private)
+static void usb_serial_port_work(struct work_struct *work)
 {
-        struct usb_serial_port *port = private;
+        struct usb_serial_port *port =
+                container_of(work, struct usb_serial_port, work);
         struct tty_struct *tty;
 
         dbg("%s - port %d", __FUNCTION__, port->number);
@@ -799,7 +800,7 @@ int usb_serial_probe(struct usb_interface *interface,
                 port->serial = serial;
                 spin_lock_init(&port->lock);
                 mutex_init(&port->mutex);
-                INIT_WORK(&port->work, usb_serial_port_work, port);
+                INIT_WORK(&port->work, usb_serial_port_work);
                 serial->port[i] = port;
         }
 
diff --git a/drivers/usb/serial/whiteheat.c b/drivers/usb/serial/whiteheat.c
index 4d1cd7aeccd3..154c7d290597 100644
--- a/drivers/usb/serial/whiteheat.c
+++ b/drivers/usb/serial/whiteheat.c
@@ -227,6 +227,7 @@ struct whiteheat_private {
         struct list_head        rx_urbs_submitted;
         struct list_head        rx_urb_q;
         struct work_struct      rx_work;
+        struct usb_serial_port  *port;
         struct list_head        tx_urbs_free;
         struct list_head        tx_urbs_submitted;
 };
@@ -241,7 +242,7 @@ static void command_port_read_callback(struct urb *urb);
 static int start_port_read(struct usb_serial_port *port);
 static struct whiteheat_urb_wrap *urb_to_wrap(struct urb *urb, struct list_head *head);
 static struct list_head *list_first(struct list_head *head);
-static void rx_data_softint(void *private);
+static void rx_data_softint(struct work_struct *work);
 
 static int firm_send_command(struct usb_serial_port *port, __u8 command, __u8 *data, __u8 datasize);
 static int firm_open(struct usb_serial_port *port);
@@ -424,7 +425,8 @@ static int whiteheat_attach (struct usb_serial *serial)
                 spin_lock_init(&info->lock);
                 info->flags = 0;
                 info->mcr = 0;
-                INIT_WORK(&info->rx_work, rx_data_softint, port);
+                INIT_WORK(&info->rx_work, rx_data_softint);
+                info->port = port;
 
                 INIT_LIST_HEAD(&info->rx_urbs_free);
                 INIT_LIST_HEAD(&info->rx_urbs_submitted);
@@ -949,7 +951,7 @@ static void whiteheat_unthrottle (struct usb_serial_port *port)
         spin_unlock_irqrestore(&info->lock, flags);
 
         if (actually_throttled)
-                rx_data_softint(port);
+                rx_data_softint(&info->rx_work);
 
         return;
 }
@@ -1400,10 +1402,11 @@ static struct list_head *list_first(struct list_head *head)
 }
 
 
-static void rx_data_softint(void *private)
+static void rx_data_softint(struct work_struct *work)
 {
-        struct usb_serial_port *port = (struct usb_serial_port *)private;
-        struct whiteheat_private *info = usb_get_serial_port_data(port);
+        struct whiteheat_private *info =
+                container_of(work, struct whiteheat_private, rx_work);
+        struct usb_serial_port *port = info->port;
         struct tty_struct *tty = port->tty;
         struct whiteheat_urb_wrap *wrap;
         struct urb *urb;