13 files changed, 87 insertions, 71 deletions

diff --git a/drivers/char/nozomi.c b/drivers/char/nozomi.c
index 0f39bec28b45..935b30d80adf 100644
--- a/drivers/char/nozomi.c
+++ b/drivers/char/nozomi.c
@@ -686,7 +686,7 @@ static int nozomi_read_config_table(struct nozomi *dc)
 
                 for (i = PORT_MDM; i < MAX_PORT; i++) {
                         kfifo_alloc(&dc->port[i].fifo_ul,
-                                FIFO_BUFFER_SIZE_UL, GFP_ATOMIC, NULL);
+                                FIFO_BUFFER_SIZE_UL, GFP_ATOMIC);
                         memset(&dc->port[i].ctrl_dl, 0, sizeof(struct ctrl_dl));
                         memset(&dc->port[i].ctrl_ul, 0, sizeof(struct ctrl_ul));
                 }
diff --git a/drivers/char/sonypi.c b/drivers/char/sonypi.c
index 9e6efb1f029f..dbcb3bd192c7 100644
--- a/drivers/char/sonypi.c
+++ b/drivers/char/sonypi.c
@@ -777,8 +777,9 @@ static void input_keyrelease(struct work_struct *work)
 {
         struct sonypi_keypress kp;
 
-        while (kfifo_get(&sonypi_device.input_fifo, (unsigned char *)&kp,
-                         sizeof(kp)) == sizeof(kp)) {
+        while (kfifo_get_locked(&sonypi_device.input_fifo, (unsigned char *)&kp,
+                         sizeof(kp), &sonypi_device.input_fifo_lock)
+                        == sizeof(kp)) {
                 msleep(10);
                 input_report_key(kp.dev, kp.key, 0);
                 input_sync(kp.dev);
@@ -827,8 +828,9 @@ static void sonypi_report_input_event(u8 event)
         if (kp.dev) {
                 input_report_key(kp.dev, kp.key, 1);
                 input_sync(kp.dev);
-                kfifo_put(&sonypi_device.input_fifo,
-                          (unsigned char *)&kp, sizeof(kp));
+                kfifo_put_locked(&sonypi_device.input_fifo,
+                        (unsigned char *)&kp, sizeof(kp),
+                        &sonypi_device.input_fifo_lock);
                 schedule_work(&sonypi_device.input_work);
         }
 }
@@ -880,7 +882,8 @@ found:
                 acpi_bus_generate_proc_event(sonypi_acpi_device, 1, event);
 #endif
 
-        kfifo_put(&sonypi_device.fifo, (unsigned char *)&event, sizeof(event));
+        kfifo_put_locked(&sonypi_device.fifo, (unsigned char *)&event,
+                        sizeof(event), &sonypi_device.fifo_lock);
         kill_fasync(&sonypi_device.fifo_async, SIGIO, POLL_IN);
         wake_up_interruptible(&sonypi_device.fifo_proc_list);
 
@@ -929,7 +932,8 @@ static ssize_t sonypi_misc_read(struct file *file, char __user *buf,
                 return ret;
 
         while (ret < count &&
-               (kfifo_get(&sonypi_device.fifo, &c, sizeof(c)) == sizeof(c))) {
+               (kfifo_get_locked(&sonypi_device.fifo, &c, sizeof(c),
+                                 &sonypi_device.fifo_lock) == sizeof(c))) {
                 if (put_user(c, buf++))
                         return -EFAULT;
                 ret++;
@@ -1313,8 +1317,7 @@ static int __devinit sonypi_probe(struct platform_device *dev)
                         "http://www.linux.it/~malattia/wiki/index.php/Sony_drivers\n");
 
         spin_lock_init(&sonypi_device.fifo_lock);
-        error = kfifo_alloc(&sonypi_device.fifo, SONYPI_BUF_SIZE, GFP_KERNEL,
-                                         &sonypi_device.fifo_lock);
+        error = kfifo_alloc(&sonypi_device.fifo, SONYPI_BUF_SIZE, GFP_KERNEL);
         if (error) {
                 printk(KERN_ERR "sonypi: kfifo_alloc failed\n");
                 return error;
@@ -1394,7 +1397,7 @@ static int __devinit sonypi_probe(struct platform_device *dev)
 
                 spin_lock_init(&sonypi_device.input_fifo_lock);
                 error = kfifo_alloc(&sonypi_device.input_fifo, SONYPI_BUF_SIZE,
-                                GFP_KERNEL, &sonypi_device.input_fifo_lock);
+                                GFP_KERNEL);
                 if (error) {
                         printk(KERN_ERR "sonypi: kfifo_alloc failed\n");
                         goto err_inpdev_unregister;
diff --git a/drivers/infiniband/hw/cxgb3/cxio_resource.c b/drivers/infiniband/hw/cxgb3/cxio_resource.c
index 65072bdfc1bf..98f24e6d906e 100644
--- a/drivers/infiniband/hw/cxgb3/cxio_resource.c
+++ b/drivers/infiniband/hw/cxgb3/cxio_resource.c
@@ -55,7 +55,7 @@ static int __cxio_init_resource_fifo(struct kfifo *fifo,
         u32 rarray[16];
         spin_lock_init(fifo_lock);
 
-        if (kfifo_alloc(fifo, nr * sizeof(u32), GFP_KERNEL, fifo_lock))
+        if (kfifo_alloc(fifo, nr * sizeof(u32), GFP_KERNEL))
                 return -ENOMEM;
 
         for (i = 0; i < skip_low + skip_high; i++)
@@ -86,7 +86,8 @@ static int __cxio_init_resource_fifo(struct kfifo *fifo,
                         __kfifo_put(fifo, (unsigned char *) &i, sizeof(u32));
 
         for (i = 0; i < skip_low + skip_high; i++)
-                kfifo_get(fifo, (unsigned char *) &entry, sizeof(u32));
+                kfifo_get_locked(fifo, (unsigned char *) &entry,
+                                sizeof(u32), fifo_lock);
         return 0;
 }
 
@@ -113,8 +114,7 @@ static int cxio_init_qpid_fifo(struct cxio_rdev *rdev_p)
         spin_lock_init(&rdev_p->rscp->qpid_fifo_lock);
 
         if (kfifo_alloc(&rdev_p->rscp->qpid_fifo, T3_MAX_NUM_QP * sizeof(u32),
-                                              GFP_KERNEL,
-                                              &rdev_p->rscp->qpid_fifo_lock))
+                                              GFP_KERNEL))
                 return -ENOMEM;
 
         for (i = 16; i < T3_MAX_NUM_QP; i++)
@@ -177,33 +177,37 @@ tpt_err:
 /*
  * returns 0 if no resource available
  */
-static u32 cxio_hal_get_resource(struct kfifo *fifo)
+static u32 cxio_hal_get_resource(struct kfifo *fifo, spinlock_t * lock)
 {
         u32 entry;
-        if (kfifo_get(fifo, (unsigned char *) &entry, sizeof(u32)))
+        if (kfifo_get_locked(fifo, (unsigned char *) &entry, sizeof(u32), lock))
                 return entry;
         else
                 return 0;       /* fifo emptry */
 }
 
-static void cxio_hal_put_resource(struct kfifo *fifo, u32 entry)
+static void cxio_hal_put_resource(struct kfifo *fifo, spinlock_t * lock,
+                u32 entry)
 {
-        BUG_ON(kfifo_put(fifo, (unsigned char *) &entry, sizeof(u32)) == 0);
+        BUG_ON(
+        kfifo_put_locked(fifo, (unsigned char *) &entry, sizeof(u32), lock)
+        == 0);
 }
 
 u32 cxio_hal_get_stag(struct cxio_hal_resource *rscp)
 {
-        return cxio_hal_get_resource(&rscp->tpt_fifo);
+        return cxio_hal_get_resource(&rscp->tpt_fifo, &rscp->tpt_fifo_lock);
 }
 
 void cxio_hal_put_stag(struct cxio_hal_resource *rscp, u32 stag)
 {
-        cxio_hal_put_resource(&rscp->tpt_fifo, stag);
+        cxio_hal_put_resource(&rscp->tpt_fifo, &rscp->tpt_fifo_lock, stag);
 }
 
 u32 cxio_hal_get_qpid(struct cxio_hal_resource *rscp)
 {
-        u32 qpid = cxio_hal_get_resource(&rscp->qpid_fifo);
+        u32 qpid = cxio_hal_get_resource(&rscp->qpid_fifo,
+                        &rscp->qpid_fifo_lock);
         PDBG("%s qpid 0x%x\n", __func__, qpid);
         return qpid;
 }
@@ -211,27 +215,27 @@ u32 cxio_hal_get_qpid(struct cxio_hal_resource *rscp)
 void cxio_hal_put_qpid(struct cxio_hal_resource *rscp, u32 qpid)
 {
         PDBG("%s qpid 0x%x\n", __func__, qpid);
-        cxio_hal_put_resource(&rscp->qpid_fifo, qpid);
+        cxio_hal_put_resource(&rscp->qpid_fifo, &rscp->qpid_fifo_lock, qpid);
 }
 
 u32 cxio_hal_get_cqid(struct cxio_hal_resource *rscp)
 {
-        return cxio_hal_get_resource(&rscp->cqid_fifo);
+        return cxio_hal_get_resource(&rscp->cqid_fifo, &rscp->cqid_fifo_lock);
 }
 
 void cxio_hal_put_cqid(struct cxio_hal_resource *rscp, u32 cqid)
 {
-        cxio_hal_put_resource(&rscp->cqid_fifo, cqid);
+        cxio_hal_put_resource(&rscp->cqid_fifo, &rscp->cqid_fifo_lock, cqid);
 }
 
 u32 cxio_hal_get_pdid(struct cxio_hal_resource *rscp)
 {
-        return cxio_hal_get_resource(&rscp->pdid_fifo);
+        return cxio_hal_get_resource(&rscp->pdid_fifo, &rscp->pdid_fifo_lock);
 }
 
 void cxio_hal_put_pdid(struct cxio_hal_resource *rscp, u32 pdid)
 {
-        cxio_hal_put_resource(&rscp->pdid_fifo, pdid);
+        cxio_hal_put_resource(&rscp->pdid_fifo, &rscp->pdid_fifo_lock, pdid);
 }
 
 void cxio_hal_destroy_resource(struct cxio_hal_resource *rscp)
diff --git a/drivers/media/video/meye.c b/drivers/media/video/meye.c
index dacbbb839b9e..38bcedfd9fec 100644
--- a/drivers/media/video/meye.c
+++ b/drivers/media/video/meye.c
@@ -800,8 +800,8 @@ again:
                 return IRQ_HANDLED;
 
         if (meye.mchip_mode == MCHIP_HIC_MODE_CONT_OUT) {
-                if (kfifo_get(&meye.grabq, (unsigned char *)&reqnr,
-                              sizeof(int)) != sizeof(int)) {
+                if (kfifo_get_locked(&meye.grabq, (unsigned char *)&reqnr,
+                              sizeof(int), &meye.grabq_lock) != sizeof(int)) {
                         mchip_free_frame();
                         return IRQ_HANDLED;
                 }
@@ -811,7 +811,8 @@ again:
                 meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
                 do_gettimeofday(&meye.grab_buffer[reqnr].timestamp);
                 meye.grab_buffer[reqnr].sequence = sequence++;
-                kfifo_put(&meye.doneq, (unsigned char *)&reqnr, sizeof(int));
+                kfifo_put_locked(&meye.doneq, (unsigned char *)&reqnr,
+                                sizeof(int), &meye.doneq_lock);
                 wake_up_interruptible(&meye.proc_list);
         } else {
                 int size;
@@ -820,8 +821,8 @@ again:
                         mchip_free_frame();
                         goto again;
                 }
-                if (kfifo_get(&meye.grabq, (unsigned char *)&reqnr,
-                              sizeof(int)) != sizeof(int)) {
+                if (kfifo_get_locked(&meye.grabq, (unsigned char *)&reqnr,
+                              sizeof(int), &meye.grabq_lock) != sizeof(int)) {
                         mchip_free_frame();
                         goto again;
                 }
@@ -831,7 +832,8 @@ again:
                 meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
                 do_gettimeofday(&meye.grab_buffer[reqnr].timestamp);
                 meye.grab_buffer[reqnr].sequence = sequence++;
-                kfifo_put(&meye.doneq, (unsigned char *)&reqnr, sizeof(int));
+                kfifo_put_locked(&meye.doneq, (unsigned char *)&reqnr,
+                                sizeof(int), &meye.doneq_lock);
                 wake_up_interruptible(&meye.proc_list);
         }
         mchip_free_frame();
@@ -933,7 +935,8 @@ static int meyeioc_qbuf_capt(int *nb)
                 mchip_cont_compression_start();
 
         meye.grab_buffer[*nb].state = MEYE_BUF_USING;
-        kfifo_put(&meye.grabq, (unsigned char *)nb, sizeof(int));
+        kfifo_put_locked(&meye.grabq, (unsigned char *)nb, sizeof(int),
+                         &meye.grabq_lock);
         mutex_unlock(&meye.lock);
 
         return 0;
@@ -965,7 +968,8 @@ static int meyeioc_sync(struct file *file, void *fh, int *i)
                 /* fall through */
         case MEYE_BUF_DONE:
                 meye.grab_buffer[*i].state = MEYE_BUF_UNUSED;
-                kfifo_get(&meye.doneq, (unsigned char *)&unused, sizeof(int));
+                kfifo_get_locked(&meye.doneq, (unsigned char *)&unused,
+                                sizeof(int), &meye.doneq_lock);
         }
         *i = meye.grab_buffer[*i].size;
         mutex_unlock(&meye.lock);
@@ -1452,7 +1456,8 @@ static int vidioc_qbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
         buf->flags |= V4L2_BUF_FLAG_QUEUED;
         buf->flags &= ~V4L2_BUF_FLAG_DONE;
         meye.grab_buffer[buf->index].state = MEYE_BUF_USING;
-        kfifo_put(&meye.grabq, (unsigned char *)&buf->index, sizeof(int));
+        kfifo_put_locked(&meye.grabq, (unsigned char *)&buf->index,
+                        sizeof(int), &meye.grabq_lock);
         mutex_unlock(&meye.lock);
 
         return 0;
@@ -1478,8 +1483,8 @@ static int vidioc_dqbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
                 return -EINTR;
         }
 
-        if (!kfifo_get(&meye.doneq, (unsigned char *)&reqnr,
-                       sizeof(int))) {
+        if (!kfifo_get_locked(&meye.doneq, (unsigned char *)&reqnr,
+                       sizeof(int), &meye.doneq_lock)) {
                 mutex_unlock(&meye.lock);
                 return -EBUSY;
         }
@@ -1745,14 +1750,14 @@ static int __devinit meye_probe(struct pci_dev *pcidev,
         }
 
         spin_lock_init(&meye.grabq_lock);
-        if (kfifo_alloc(&meye.grabq, sizeof(int) * MEYE_MAX_BUFNBRS, GFP_KERNEL,
-                                 &meye.grabq_lock)) {
+        if (kfifo_alloc(&meye.grabq, sizeof(int) * MEYE_MAX_BUFNBRS,
+                                GFP_KERNEL)) {
                 printk(KERN_ERR "meye: fifo allocation failed\n");
                 goto outkfifoalloc1;
         }
         spin_lock_init(&meye.doneq_lock);
-        if (kfifo_alloc(&meye.doneq, sizeof(int) * MEYE_MAX_BUFNBRS, GFP_KERNEL,
-                                 &meye.doneq_lock)) {
+        if (kfifo_alloc(&meye.doneq, sizeof(int) * MEYE_MAX_BUFNBRS,
+                                GFP_KERNEL)) {
                 printk(KERN_ERR "meye: fifo allocation failed\n");
                 goto outkfifoalloc2;
         }
diff --git a/drivers/net/wireless/libertas/main.c b/drivers/net/wireless/libertas/main.c
index 403909287414..2cc7ecd8d123 100644
--- a/drivers/net/wireless/libertas/main.c
+++ b/drivers/net/wireless/libertas/main.c
@@ -883,7 +883,7 @@ static int lbs_init_adapter(struct lbs_private *priv)
         priv->resp_len[0] = priv->resp_len[1] = 0;
 
         /* Create the event FIFO */
-        ret = kfifo_alloc(&priv->event_fifo, sizeof(u32) * 16, GFP_KERNEL, NULL);
+        ret = kfifo_alloc(&priv->event_fifo, sizeof(u32) * 16, GFP_KERNEL);
         if (ret) {
                 lbs_pr_err("Out of memory allocating event FIFO buffer\n");
                 goto out;
diff --git a/drivers/platform/x86/fujitsu-laptop.c b/drivers/platform/x86/fujitsu-laptop.c
index f999fba0e25e..13dc7bedcfce 100644
--- a/drivers/platform/x86/fujitsu-laptop.c
+++ b/drivers/platform/x86/fujitsu-laptop.c
@@ -825,7 +825,7 @@ static int acpi_fujitsu_hotkey_add(struct acpi_device *device)
         /* kfifo */
         spin_lock_init(&fujitsu_hotkey->fifo_lock);
         error = kfifo_alloc(&fujitsu_hotkey->fifo, RINGBUFFERSIZE * sizeof(int),
-                        GFP_KERNEL, &fujitsu_hotkey->fifo_lock);
+                        GFP_KERNEL);
         if (error) {
                 printk(KERN_ERR "kfifo_alloc failed\n");
                 goto err_stop;
@@ -1006,9 +1006,10 @@ static void acpi_fujitsu_hotkey_notify(struct acpi_device *device, u32 event)
                                 vdbg_printk(FUJLAPTOP_DBG_TRACE,
                                         "Push keycode into ringbuffer [%d]\n",
                                         keycode);
-                                status = kfifo_put(&fujitsu_hotkey->fifo,
+                                status = kfifo_put_locked(&fujitsu_hotkey->fifo,
                                                    (unsigned char *)&keycode,
-                                                   sizeof(keycode));
+                                                   sizeof(keycode),
+                                                   &fujitsu_hotkey->fifo_lock);
                                 if (status != sizeof(keycode)) {
                                         vdbg_printk(FUJLAPTOP_DBG_WARN,
                                             "Could not push keycode [0x%x]\n",
@@ -1019,11 +1020,12 @@ static void acpi_fujitsu_hotkey_notify(struct acpi_device *device, u32 event)
                                 }
                         } else if (keycode == 0) {
                                 while ((status =
-                                        kfifo_get
-                                        (&fujitsu_hotkey->fifo, (unsigned char *)
-                                         &keycode_r,
-                                         sizeof
-                                         (keycode_r))) == sizeof(keycode_r)) {
+                                        kfifo_get_locked(
+                                         &fujitsu_hotkey->fifo,
+                                         (unsigned char *) &keycode_r,
+                                         sizeof(keycode_r),
+                                         &fujitsu_hotkey->fifo_lock))
+                                         == sizeof(keycode_r)) {
                                         input_report_key(input, keycode_r, 0);
                                         input_sync(input);
                                         vdbg_printk(FUJLAPTOP_DBG_TRACE,
diff --git a/drivers/platform/x86/sony-laptop.c b/drivers/platform/x86/sony-laptop.c
index 04625a048e74..1538a0a3c0af 100644
--- a/drivers/platform/x86/sony-laptop.c
+++ b/drivers/platform/x86/sony-laptop.c
@@ -300,8 +300,9 @@ static void do_sony_laptop_release_key(struct work_struct *work)
 {
         struct sony_laptop_keypress kp;
 
-        while (kfifo_get(&sony_laptop_input.fifo, (unsigned char *)&kp,
-                         sizeof(kp)) == sizeof(kp)) {
+        while (kfifo_get_locked(&sony_laptop_input.fifo, (unsigned char *)&kp,
+                        sizeof(kp), &sony_laptop_input.fifo_lock)
+                        == sizeof(kp)) {
                 msleep(10);
                 input_report_key(kp.dev, kp.key, 0);
                 input_sync(kp.dev);
@@ -362,8 +363,9 @@ static void sony_laptop_report_input_event(u8 event)
                 /* we emit the scancode so we can always remap the key */
                 input_event(kp.dev, EV_MSC, MSC_SCAN, event);
                 input_sync(kp.dev);
-                kfifo_put(&sony_laptop_input.fifo,
-                          (unsigned char *)&kp, sizeof(kp));
+                kfifo_put_locked(&sony_laptop_input.fifo,
+                          (unsigned char *)&kp, sizeof(kp),
+                          &sony_laptop_input.fifo_lock);
 
                 if (!work_pending(&sony_laptop_release_key_work))
                         queue_work(sony_laptop_input.wq,
@@ -386,8 +388,7 @@ static int sony_laptop_setup_input(struct acpi_device *acpi_device)
         /* kfifo */
         spin_lock_init(&sony_laptop_input.fifo_lock);
         error =
-         kfifo_alloc(&sony_laptop_input.fifo, SONY_LAPTOP_BUF_SIZE, GFP_KERNEL,
-                            &sony_laptop_input.fifo_lock);
+         kfifo_alloc(&sony_laptop_input.fifo, SONY_LAPTOP_BUF_SIZE, GFP_KERNEL);
         if (error) {
                 printk(KERN_ERR DRV_PFX "kfifo_alloc failed\n");
                 goto err_dec_users;
@@ -2129,7 +2130,8 @@ static ssize_t sonypi_misc_read(struct file *file, char __user *buf,
                 return ret;
 
         while (ret < count &&
-               (kfifo_get(&sonypi_compat.fifo, &c, sizeof(c)) == sizeof(c))) {
+               (kfifo_get_locked(&sonypi_compat.fifo, &c, sizeof(c),
+                          &sonypi_compat.fifo_lock) == sizeof(c))) {
                 if (put_user(c, buf++))
                         return -EFAULT;
                 ret++;
@@ -2308,7 +2310,8 @@ static struct miscdevice sonypi_misc_device = {
 
 static void sonypi_compat_report_event(u8 event)
 {
-        kfifo_put(&sonypi_compat.fifo, (unsigned char *)&event, sizeof(event));
+        kfifo_put_locked(&sonypi_compat.fifo, (unsigned char *)&event,
+                        sizeof(event), &sonypi_compat.fifo_lock);
         kill_fasync(&sonypi_compat.fifo_async, SIGIO, POLL_IN);
         wake_up_interruptible(&sonypi_compat.fifo_proc_list);
 }
@@ -2319,8 +2322,7 @@ static int sonypi_compat_init(void)
 
         spin_lock_init(&sonypi_compat.fifo_lock);
         error =
-         kfifo_alloc(&sonypi_compat.fifo, SONY_LAPTOP_BUF_SIZE, GFP_KERNEL,
-                                         &sonypi_compat.fifo_lock);
+         kfifo_alloc(&sonypi_compat.fifo, SONY_LAPTOP_BUF_SIZE, GFP_KERNEL);
         if (error) {
                 printk(KERN_ERR DRV_PFX "kfifo_alloc failed\n");
                 return error;
diff --git a/drivers/scsi/libiscsi.c b/drivers/scsi/libiscsi.c
index cf0aa7e90be9..1bccbc1e588e 100644
--- a/drivers/scsi/libiscsi.c
+++ b/drivers/scsi/libiscsi.c
@@ -2461,7 +2461,7 @@ iscsi_pool_init(struct iscsi_pool *q, int max, void ***items, int item_size)
         if (q->pool == NULL)
                 return -ENOMEM;
 
-        kfifo_init(&q->queue, (void*)q->pool, max * sizeof(void*), NULL);
+        kfifo_init(&q->queue, (void*)q->pool, max * sizeof(void*));
 
         for (i = 0; i < max; i++) {
                 q->pool[i] = kzalloc(item_size, GFP_KERNEL);
diff --git a/drivers/scsi/libiscsi_tcp.c b/drivers/scsi/libiscsi_tcp.c
index a83ee56a185e..41643c860d26 100644
--- a/drivers/scsi/libiscsi_tcp.c
+++ b/drivers/scsi/libiscsi_tcp.c
@@ -1128,7 +1128,7 @@ int iscsi_tcp_r2tpool_alloc(struct iscsi_session *session)
 
                 /* R2T xmit queue */
                 if (kfifo_alloc(&tcp_task->r2tqueue,
-                      session->max_r2t * 4 * sizeof(void*), GFP_KERNEL, NULL)) {
+                      session->max_r2t * 4 * sizeof(void*), GFP_KERNEL)) {
                         iscsi_pool_free(&tcp_task->r2tpool);
                         goto r2t_alloc_fail;
                 }
diff --git a/drivers/scsi/libsrp.c b/drivers/scsi/libsrp.c
index b1b5e51ca8e3..db1b41c55fd3 100644
--- a/drivers/scsi/libsrp.c
+++ b/drivers/scsi/libsrp.c
@@ -58,8 +58,7 @@ static int srp_iu_pool_alloc(struct srp_queue *q, size_t max,
                 goto free_pool;
 
         spin_lock_init(&q->lock);
-        kfifo_init(&q->queue, (void *) q->pool, max * sizeof(void *),
-                              &q->lock);
+        kfifo_init(&q->queue, (void *) q->pool, max * sizeof(void *));
 
         for (i = 0, iue = q->items; i < max; i++) {
                 __kfifo_put(&q->queue, (void *) &iue, sizeof(void *));
@@ -164,7 +163,8 @@ struct iu_entry *srp_iu_get(struct srp_target *target)
 {
         struct iu_entry *iue = NULL;
 
-        kfifo_get(&target->iu_queue.queue, (void *) &iue, sizeof(void *));
+        kfifo_get_locked(&target->iu_queue.queue, (void *) &iue,
+                        sizeof(void *), &target->iu_queue.lock);
         if (!iue)
                 return iue;
         iue->target = target;
@@ -176,7 +176,8 @@ EXPORT_SYMBOL_GPL(srp_iu_get);
 
 void srp_iu_put(struct iu_entry *iue)
 {
-        kfifo_put(&iue->target->iu_queue.queue, (void *) &iue, sizeof(void *));
+        kfifo_put_locked(&iue->target->iu_queue.queue, (void *) &iue,
+                        sizeof(void *), &iue->target->iu_queue.lock);
 }
 EXPORT_SYMBOL_GPL(srp_iu_put);
 
diff --git a/drivers/usb/host/fhci.h b/drivers/usb/host/fhci.h
index 2277428ef5d3..a76da201183b 100644
--- a/drivers/usb/host/fhci.h
+++ b/drivers/usb/host/fhci.h
@@ -495,7 +495,7 @@ static inline struct usb_hcd *fhci_to_hcd(struct fhci_hcd *fhci)
 /* fifo of pointers */
 static inline int cq_new(struct kfifo *fifo, int size)
 {
-        return kfifo_alloc(fifo, size * sizeof(void *), GFP_KERNEL, NULL);
+        return kfifo_alloc(fifo, size * sizeof(void *), GFP_KERNEL);
 }
 
 static inline void cq_delete(struct kfifo *kfifo)
diff --git a/drivers/usb/serial/generic.c b/drivers/usb/serial/generic.c
index bbe005cefcfb..61eef18218be 100644
--- a/drivers/usb/serial/generic.c
+++ b/drivers/usb/serial/generic.c
@@ -285,7 +285,7 @@ static int usb_serial_generic_write_start(struct usb_serial_port *port)
                 return 0;
 
         data = port->write_urb->transfer_buffer;
-        count = kfifo_get(port->write_fifo, data, port->bulk_out_size);
+        count = kfifo_get_locked(port->write_fifo, data, port->bulk_out_size, &port->lock);
         usb_serial_debug_data(debug, &port->dev, __func__, count, data);
 
         /* set up our urb */
@@ -345,7 +345,7 @@ int usb_serial_generic_write(struct tty_struct *tty,
                 return usb_serial_multi_urb_write(tty, port,
                                                   buf, count);
 
-        count = kfifo_put(port->write_fifo, buf, count);
+        count = kfifo_put_locked(port->write_fifo, buf, count, &port->lock);
         result = usb_serial_generic_write_start(port);
 
         if (result >= 0)
diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c
index 44b72d47fac2..636a4f23445e 100644
--- a/drivers/usb/serial/usb-serial.c
+++ b/drivers/usb/serial/usb-serial.c
@@ -939,8 +939,7 @@ int usb_serial_probe(struct usb_interface *interface,
                         dev_err(&interface->dev, "No free urbs available\n");
                         goto probe_error;
                 }
-                if (kfifo_alloc(&port->write_fifo, PAGE_SIZE, GFP_KERNEL,
-                        &port->lock))
+                if (kfifo_alloc(port->write_fifo, PAGE_SIZE, GFP_KERNEL))
                         goto probe_error;
                 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
                 port->bulk_out_size = buffer_size;