7 files changed, 61 insertions, 164 deletions

diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c
index 31fc76960a8f..0c73fe39a236 100644
--- a/drivers/ide/ide-cd.c
+++ b/drivers/ide/ide-cd.c
@@ -31,7 +31,6 @@
 #include <linux/delay.h>
 #include <linux/timer.h>
 #include <linux/seq_file.h>
-#include <linux/smp_lock.h>
 #include <linux/slab.h>
 #include <linux/interrupt.h>
 #include <linux/errno.h>
@@ -52,6 +51,7 @@
 
 #include "ide-cd.h"
 
+static DEFINE_MUTEX(ide_cd_mutex);
 static DEFINE_MUTEX(idecd_ref_mutex);
 
 static void ide_cd_release(struct device *);
@@ -1602,7 +1602,7 @@ static int idecd_open(struct block_device *bdev, fmode_t mode)
         struct cdrom_info *info;
         int rc = -ENXIO;
 
-        lock_kernel();
+        mutex_lock(&ide_cd_mutex);
         info = ide_cd_get(bdev->bd_disk);
         if (!info)
                 goto out;
@@ -1611,7 +1611,7 @@ static int idecd_open(struct block_device *bdev, fmode_t mode)
         if (rc < 0)
                 ide_cd_put(info);
 out:
-        unlock_kernel();
+        mutex_unlock(&ide_cd_mutex);
         return rc;
 }
 
@@ -1619,11 +1619,11 @@ static int idecd_release(struct gendisk *disk, fmode_t mode)
 {
         struct cdrom_info *info = ide_drv_g(disk, cdrom_info);
 
-        lock_kernel();
+        mutex_lock(&ide_cd_mutex);
         cdrom_release(&info->devinfo, mode);
 
         ide_cd_put(info);
-        unlock_kernel();
+        mutex_unlock(&ide_cd_mutex);
 
         return 0;
 }
@@ -1694,9 +1694,9 @@ static int idecd_ioctl(struct block_device *bdev, fmode_t mode,
 {
         int ret;
 
-        lock_kernel();
+        mutex_lock(&ide_cd_mutex);
         ret = idecd_locked_ioctl(bdev, mode, cmd, arg);
-        unlock_kernel();
+        mutex_unlock(&ide_cd_mutex);
 
         return ret;
 }
diff --git a/drivers/ide/ide-cs.c b/drivers/ide/ide-cs.c
index 2a4cb9c18f01..404843e8611b 100644
--- a/drivers/ide/ide-cs.c
+++ b/drivers/ide/ide-cs.c
@@ -43,7 +43,6 @@
 #include <asm/io.h>
 #include <asm/system.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
 #include <pcmcia/cisreg.h>
@@ -72,17 +71,6 @@ static int ide_config(struct pcmcia_device *);
 
 static void ide_detach(struct pcmcia_device *p_dev);
 
-
-
-
-/*======================================================================
-
-    ide_attach() creates an "instance" of the driver, allocating
-    local data structures for one device.  The device is registered
-    with Card Services.
-
-======================================================================*/
-
 static int ide_probe(struct pcmcia_device *link)
 {
     ide_info_t *info;
@@ -97,23 +85,12 @@ static int ide_probe(struct pcmcia_device *link)
     info->p_dev = link;
     link->priv = info;
 
-    link->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
-    link->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;
-    link->conf.Attributes = CONF_ENABLE_IRQ;
-    link->conf.IntType = INT_MEMORY_AND_IO;
+    link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO |
+            CONF_AUTO_SET_VPP | CONF_AUTO_CHECK_VCC;
 
     return ide_config(link);
 } /* ide_attach */
 
-/*======================================================================
-
-    This deletes a driver "instance".  The device is de-registered
-    with Card Services.  If it has been released, all local data
-    structures are freed.  Otherwise, the structures will be freed
-    when the device is released.
-
-======================================================================*/
-
 static void ide_detach(struct pcmcia_device *link)
 {
     ide_info_t *info = link->priv;
@@ -187,79 +164,31 @@ out_release:
     return NULL;
 }
 
-/*======================================================================
-
-    ide_config() is scheduled to run after a CARD_INSERTION event
-    is received, to configure the PCMCIA socket, and to make the
-    ide device available to the system.
-
-======================================================================*/
-
-struct pcmcia_config_check {
-        unsigned long ctl_base;
-        int skip_vcc;
-        int is_kme;
-};
-
-static int pcmcia_check_one_config(struct pcmcia_device *pdev,
-                                   cistpl_cftable_entry_t *cfg,
-                                   cistpl_cftable_entry_t *dflt,
-                                   unsigned int vcc,
-                                   void *priv_data)
+static int pcmcia_check_one_config(struct pcmcia_device *pdev, void *priv_data)
 {
-        struct pcmcia_config_check *stk = priv_data;
-
-        /* Check for matching Vcc, unless we're desperate */
-        if (!stk->skip_vcc) {
-                if (cfg->vcc.present & (1 << CISTPL_POWER_VNOM)) {
-                        if (vcc != cfg->vcc.param[CISTPL_POWER_VNOM] / 10000)
-                                return -ENODEV;
-                } else if (dflt->vcc.present & (1 << CISTPL_POWER_VNOM)) {
-                        if (vcc != dflt->vcc.param[CISTPL_POWER_VNOM] / 10000)
-                                return -ENODEV;
-                }
-        }
+        int *is_kme = priv_data;
 
-        if (cfg->vpp1.present & (1 << CISTPL_POWER_VNOM))
-                pdev->conf.Vpp = cfg->vpp1.param[CISTPL_POWER_VNOM] / 10000;
-        else if (dflt->vpp1.present & (1 << CISTPL_POWER_VNOM))
-                pdev->conf.Vpp = dflt->vpp1.param[CISTPL_POWER_VNOM] / 10000;
-
-        if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
-                cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
-                pdev->io_lines = io->flags & CISTPL_IO_LINES_MASK;
-
-                pdev->conf.ConfigIndex = cfg->index;
-                pdev->resource[0]->start = io->win[0].base;
-                if (!(io->flags & CISTPL_IO_16BIT)) {
-                        pdev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
-                        pdev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
-                }
-                if (io->nwin == 2) {
-                        pdev->resource[0]->end = 8;
-                        pdev->resource[1]->start = io->win[1].base;
-                        pdev->resource[1]->end = (stk->is_kme) ? 2 : 1;
-                        if (pcmcia_request_io(pdev) != 0)
-                                return -ENODEV;
-                        stk->ctl_base = pdev->resource[1]->start;
-                } else if ((io->nwin == 1) && (io->win[0].len >= 16)) {
-                        pdev->resource[0]->end = io->win[0].len;
-                        pdev->resource[1]->end = 0;
-                        if (pcmcia_request_io(pdev) != 0)
-                                return -ENODEV;
-                        stk->ctl_base = pdev->resource[0]->start + 0x0e;
-                } else
+        if (!(pdev->resource[0]->flags & IO_DATA_PATH_WIDTH_8)) {
+                pdev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
+                pdev->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
+        }
+        pdev->resource[1]->flags &= ~IO_DATA_PATH_WIDTH;
+        pdev->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;
+
+        if (pdev->resource[1]->end) {
+                pdev->resource[0]->end = 8;
+                pdev->resource[1]->end = (*is_kme) ? 2 : 1;
+        } else {
+                if (pdev->resource[0]->end < 16)
                         return -ENODEV;
-                /* If we've got this far, we're done */
-                return 0;
         }
-        return -ENODEV;
+
+        return pcmcia_request_io(pdev);
 }
 
 static int ide_config(struct pcmcia_device *link)
 {
     ide_info_t *info = link->priv;
-    struct pcmcia_config_check *stk = NULL;
     int ret = 0, is_kme = 0;
     unsigned long io_base, ctl_base;
     struct ide_host *host;
@@ -270,23 +199,21 @@ static int ide_config(struct pcmcia_device *link)
               ((link->card_id == PRODID_KME_KXLC005_A) ||
                (link->card_id == PRODID_KME_KXLC005_B)));
 
-    stk = kzalloc(sizeof(*stk), GFP_KERNEL);
-    if (!stk)
-            goto err_mem;
-    stk->is_kme = is_kme;
-    stk->skip_vcc = io_base = ctl_base = 0;
-
-    if (pcmcia_loop_config(link, pcmcia_check_one_config, stk)) {
-            stk->skip_vcc = 1;
-            if (pcmcia_loop_config(link, pcmcia_check_one_config, stk))
+    if (pcmcia_loop_config(link, pcmcia_check_one_config, &is_kme)) {
+            link->config_flags &= ~CONF_AUTO_CHECK_VCC;
+            if (pcmcia_loop_config(link, pcmcia_check_one_config, &is_kme))
                     goto failed; /* No suitable config found */
     }
     io_base = link->resource[0]->start;
-    ctl_base = stk->ctl_base;
+    if (link->resource[1]->end)
+            ctl_base = link->resource[1]->start;
+    else
+            ctl_base = link->resource[0]->start + 0x0e;
 
     if (!link->irq)
             goto failed;
-    ret = pcmcia_request_configuration(link, &link->conf);
+
+    ret = pcmcia_enable_device(link);
     if (ret)
             goto failed;
 
@@ -311,29 +238,15 @@ static int ide_config(struct pcmcia_device *link)
     info->host = host;
     dev_info(&link->dev, "ide-cs: hd%c: Vpp = %d.%d\n",
             'a' + host->ports[0]->index * 2,
-            link->conf.Vpp / 10, link->conf.Vpp % 10);
+            link->vpp / 10, link->vpp % 10);
 
-    kfree(stk);
     return 0;
 
-err_mem:
-    printk(KERN_NOTICE "ide-cs: ide_config failed memory allocation\n");
-    goto failed;
-
 failed:
-    kfree(stk);
     ide_release(link);
     return -ENODEV;
 } /* ide_config */
 
-/*======================================================================
-
-    After a card is removed, ide_release() will unregister the net
-    device, and release the PCMCIA configuration.  If the device is
-    still open, this will be postponed until it is closed.
-
-======================================================================*/
-
 static void ide_release(struct pcmcia_device *link)
 {
     ide_info_t *info = link->priv;
@@ -359,15 +272,6 @@ static void ide_release(struct pcmcia_device *link)
 } /* ide_release */
 
 
-/*======================================================================
-
-    The card status event handler.  Mostly, this schedules other
-    stuff to run after an event is received.  A CARD_REMOVAL event
-    also sets some flags to discourage the ide drivers from
-    talking to the ports.
-
-======================================================================*/
-
 static struct pcmcia_device_id ide_ids[] = {
         PCMCIA_DEVICE_FUNC_ID(4),
         PCMCIA_DEVICE_MANF_CARD(0x0000, 0x0000),        /* Corsair */
@@ -440,9 +344,7 @@ MODULE_DEVICE_TABLE(pcmcia, ide_ids);
 
 static struct pcmcia_driver ide_cs_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = "ide-cs",
-        },
+        .name           = "ide-cs",
         .probe          = ide_probe,
         .remove         = ide_detach,
         .id_table       = ide_ids,
diff --git a/drivers/ide/ide-disk_ioctl.c b/drivers/ide/ide-disk_ioctl.c
index ec94c66918f6..da36f729ff32 100644
--- a/drivers/ide/ide-disk_ioctl.c
+++ b/drivers/ide/ide-disk_ioctl.c
@@ -1,10 +1,11 @@
 #include <linux/kernel.h>
 #include <linux/ide.h>
 #include <linux/hdreg.h>
-#include <linux/smp_lock.h>
+#include <linux/mutex.h>
 
 #include "ide-disk.h"
 
+static DEFINE_MUTEX(ide_disk_ioctl_mutex);
 static const struct ide_ioctl_devset ide_disk_ioctl_settings[] = {
 { HDIO_GET_ADDRESS,     HDIO_SET_ADDRESS,   &ide_devset_address   },
 { HDIO_GET_MULTCOUNT,   HDIO_SET_MULTCOUNT, &ide_devset_multcount },
@@ -19,13 +20,13 @@ int ide_disk_ioctl(ide_drive_t *drive, struct block_device *bdev, fmode_t mode,
 {
         int err;
 
-        lock_kernel();
+        mutex_lock(&ide_disk_ioctl_mutex);
         err = ide_setting_ioctl(drive, bdev, cmd, arg, ide_disk_ioctl_settings);
         if (err != -EOPNOTSUPP)
                 goto out;
 
         err = generic_ide_ioctl(drive, bdev, cmd, arg);
 out:
-        unlock_kernel();
+        mutex_unlock(&ide_disk_ioctl_mutex);
         return err;
 }
diff --git a/drivers/ide/ide-floppy_ioctl.c b/drivers/ide/ide-floppy_ioctl.c
index fd3d05ab3417..d267b7affad6 100644
--- a/drivers/ide/ide-floppy_ioctl.c
+++ b/drivers/ide/ide-floppy_ioctl.c
@@ -5,7 +5,7 @@
 #include <linux/kernel.h>
 #include <linux/ide.h>
 #include <linux/cdrom.h>
-#include <linux/smp_lock.h>
+#include <linux/mutex.h>
 
 #include <asm/unaligned.h>
 
@@ -32,6 +32,7 @@
  * On exit we set nformats to the number of records we've actually initialized.
  */
 
+static DEFINE_MUTEX(ide_floppy_ioctl_mutex);
 static int ide_floppy_get_format_capacities(ide_drive_t *drive,
                                             struct ide_atapi_pc *pc,
                                             int __user *arg)
@@ -276,7 +277,7 @@ int ide_floppy_ioctl(ide_drive_t *drive, struct block_device *bdev,
         void __user *argp = (void __user *)arg;
         int err;
 
-        lock_kernel();
+        mutex_lock(&ide_floppy_ioctl_mutex);
         if (cmd == CDROMEJECT || cmd == CDROM_LOCKDOOR) {
                 err = ide_floppy_lockdoor(drive, &pc, arg, cmd);
                 goto out;
@@ -298,6 +299,6 @@ int ide_floppy_ioctl(ide_drive_t *drive, struct block_device *bdev,
                 err = generic_ide_ioctl(drive, bdev, cmd, arg);
 
 out:
-        unlock_kernel();
+        mutex_unlock(&ide_floppy_ioctl_mutex);
         return err;
 }
diff --git a/drivers/ide/ide-gd.c b/drivers/ide/ide-gd.c
index 70aeeb18833e..35c4b43585e3 100644
--- a/drivers/ide/ide-gd.c
+++ b/drivers/ide/ide-gd.c
@@ -1,4 +1,3 @@
-#include <linux/smp_lock.h>
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/string.h>
@@ -23,6 +22,7 @@
 #define IDE_GD_VERSION  "1.18"
 
 /* module parameters */
+static DEFINE_MUTEX(ide_gd_mutex);
 static unsigned long debug_mask;
 module_param(debug_mask, ulong, 0644);
 
@@ -242,9 +242,9 @@ static int ide_gd_unlocked_open(struct block_device *bdev, fmode_t mode)
 {
         int ret;
 
-        lock_kernel();
+        mutex_lock(&ide_gd_mutex);
         ret = ide_gd_open(bdev, mode);
-        unlock_kernel();
+        mutex_unlock(&ide_gd_mutex);
 
         return ret;
 }
@@ -257,7 +257,7 @@ static int ide_gd_release(struct gendisk *disk, fmode_t mode)
 
         ide_debug_log(IDE_DBG_FUNC, "enter");
 
-        lock_kernel();
+        mutex_lock(&ide_gd_mutex);
         if (idkp->openers == 1)
                 drive->disk_ops->flush(drive);
 
@@ -269,7 +269,7 @@ static int ide_gd_release(struct gendisk *disk, fmode_t mode)
         idkp->openers--;
 
         ide_disk_put(idkp);
-        unlock_kernel();
+        mutex_unlock(&ide_gd_mutex);
 
         return 0;
 }
diff --git a/drivers/ide/ide-probe.c b/drivers/ide/ide-probe.c
index 4c3d1bfec0c5..068cef0a987a 100644
--- a/drivers/ide/ide-probe.c
+++ b/drivers/ide/ide-probe.c
@@ -1448,19 +1448,13 @@ int ide_host_register(struct ide_host *host, const struct ide_port_info *d,
                 if (hwif == NULL)
                         continue;
 
-                if (hwif->present)
-                        hwif_register_devices(hwif);
-        }
-
-        ide_host_for_each_port(i, hwif, host) {
-                if (hwif == NULL)
-                        continue;
-
                 ide_sysfs_register_port(hwif);
                 ide_proc_register_port(hwif);
 
-                if (hwif->present)
+                if (hwif->present) {
                         ide_proc_port_register_devices(hwif);
+                        hwif_register_devices(hwif);
+                }
         }
 
         return j ? 0 : -1;
diff --git a/drivers/ide/ide-tape.c b/drivers/ide/ide-tape.c
index 23d1d1c5587c..7ecb1ade8874 100644
--- a/drivers/ide/ide-tape.c
+++ b/drivers/ide/ide-tape.c
@@ -32,11 +32,9 @@
 #include <linux/errno.h>
 #include <linux/genhd.h>
 #include <linux/seq_file.h>
-#include <linux/smp_lock.h>
 #include <linux/slab.h>
 #include <linux/pci.h>
 #include <linux/ide.h>
-#include <linux/smp_lock.h>
 #include <linux/completion.h>
 #include <linux/bitops.h>
 #include <linux/mutex.h>
@@ -220,6 +218,7 @@ typedef struct ide_tape_obj {
         char write_prot;
 } idetape_tape_t;
 
+static DEFINE_MUTEX(ide_tape_mutex);
 static DEFINE_MUTEX(idetape_ref_mutex);
 
 static DEFINE_MUTEX(idetape_chrdev_mutex);
@@ -1426,9 +1425,9 @@ static long idetape_chrdev_ioctl(struct file *file,
                                 unsigned int cmd, unsigned long arg)
 {
         long ret;
-        lock_kernel();
+        mutex_lock(&ide_tape_mutex);
         ret = do_idetape_chrdev_ioctl(file, cmd, arg);
-        unlock_kernel();
+        mutex_unlock(&ide_tape_mutex);
         return ret;
 }
 
@@ -1910,9 +1909,9 @@ static int idetape_open(struct block_device *bdev, fmode_t mode)
 {
         struct ide_tape_obj *tape;
 
-        lock_kernel();
+        mutex_lock(&ide_tape_mutex);
         tape = ide_tape_get(bdev->bd_disk, false, 0);
-        unlock_kernel();
+        mutex_unlock(&ide_tape_mutex);
 
         if (!tape)
                 return -ENXIO;
@@ -1924,9 +1923,9 @@ static int idetape_release(struct gendisk *disk, fmode_t mode)
 {
         struct ide_tape_obj *tape = ide_drv_g(disk, ide_tape_obj);
 
-        lock_kernel();
+        mutex_lock(&ide_tape_mutex);
         ide_tape_put(tape);
-        unlock_kernel();
+        mutex_unlock(&ide_tape_mutex);
 
         return 0;
 }
@@ -1938,11 +1937,11 @@ static int idetape_ioctl(struct block_device *bdev, fmode_t mode,
         ide_drive_t *drive = tape->drive;
         int err;
 
-        lock_kernel();
+        mutex_lock(&ide_tape_mutex);
         err = generic_ide_ioctl(drive, bdev, cmd, arg);
         if (err == -EINVAL)
                 err = idetape_blkdev_ioctl(drive, cmd, arg);
-        unlock_kernel();
+        mutex_unlock(&ide_tape_mutex);
 
         return err;
 }