Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6 into rmobile-latest

5 files changed, 63 insertions, 40 deletions

diff --git a/drivers/media/video/cx88/cx88-blackbird.c b/drivers/media/video/cx88/cx88-blackbird.c
index bca307eb1e24..11e49bbc4a66 100644
--- a/drivers/media/video/cx88/cx88-blackbird.c
+++ b/drivers/media/video/cx88/cx88-blackbird.c
@@ -1060,18 +1060,21 @@ static int mpeg_open(struct file *file)
 
         /* Make sure we can acquire the hardware */
         drv = cx8802_get_driver(dev, CX88_MPEG_BLACKBIRD);
-        if (drv) {
-                err = drv->request_acquire(drv);
-                if(err != 0) {
-                        dprintk(1,"%s: Unable to acquire hardware, %d\n", __func__, err);
-                        mutex_unlock(&dev->core->lock);
-                        return err;
-                }
+        if (!drv) {
+                dprintk(1, "%s: blackbird driver is not loaded\n", __func__);
+                mutex_unlock(&dev->core->lock);
+                return -ENODEV;
+        }
+
+        err = drv->request_acquire(drv);
+        if (err != 0) {
+                dprintk(1,"%s: Unable to acquire hardware, %d\n", __func__, err);
+                mutex_unlock(&dev->core->lock);
+                return err;
         }
 
-        if (!atomic_read(&dev->core->mpeg_users) && blackbird_initialize_codec(dev) < 0) {
-                if (drv)
-                        drv->request_release(drv);
+        if (!dev->core->mpeg_users && blackbird_initialize_codec(dev) < 0) {
+                drv->request_release(drv);
                 mutex_unlock(&dev->core->lock);
                 return -EINVAL;
         }
@@ -1080,8 +1083,7 @@ static int mpeg_open(struct file *file)
         /* allocate + initialize per filehandle data */
         fh = kzalloc(sizeof(*fh),GFP_KERNEL);
         if (NULL == fh) {
-                if (drv)
-                        drv->request_release(drv);
+                drv->request_release(drv);
                 mutex_unlock(&dev->core->lock);
                 return -ENOMEM;
         }
@@ -1099,7 +1101,7 @@ static int mpeg_open(struct file *file)
         cx88_set_scale(dev->core, dev->width, dev->height,
                         fh->mpegq.field);
 
-        atomic_inc(&dev->core->mpeg_users);
+        dev->core->mpeg_users++;
         mutex_unlock(&dev->core->lock);
         return 0;
 }
@@ -1110,7 +1112,9 @@ static int mpeg_release(struct file *file)
         struct cx8802_dev *dev = fh->dev;
         struct cx8802_driver *drv = NULL;
 
-        if (dev->mpeg_active && atomic_read(&dev->core->mpeg_users) == 1)
+        mutex_lock(&dev->core->lock);
+
+        if (dev->mpeg_active && dev->core->mpeg_users == 1)
                 blackbird_stop_codec(dev);
 
         cx8802_cancel_buffers(fh->dev);
@@ -1119,17 +1123,18 @@ static int mpeg_release(struct file *file)
 
         videobuf_mmap_free(&fh->mpegq);
 
-        mutex_lock(&dev->core->lock);
         file->private_data = NULL;
         kfree(fh);
-        mutex_unlock(&dev->core->lock);
 
         /* Make sure we release the hardware */
         drv = cx8802_get_driver(dev, CX88_MPEG_BLACKBIRD);
+        WARN_ON(!drv);
         if (drv)
                 drv->request_release(drv);
 
-        atomic_dec(&dev->core->mpeg_users);
+        dev->core->mpeg_users--;
+
+        mutex_unlock(&dev->core->lock);
 
         return 0;
 }
@@ -1334,11 +1339,9 @@ static int cx8802_blackbird_probe(struct cx8802_driver *drv)
         blackbird_register_video(dev);
 
         /* initial device configuration: needed ? */
-        mutex_lock(&dev->core->lock);
 //      init_controls(core);
         cx88_set_tvnorm(core,core->tvnorm);
         cx88_video_mux(core,0);
-        mutex_unlock(&dev->core->lock);
 
         return 0;
 
diff --git a/drivers/media/video/cx88/cx88-dvb.c b/drivers/media/video/cx88/cx88-dvb.c
index 7b8c9d3b6efc..c69df7ebb6a7 100644
--- a/drivers/media/video/cx88/cx88-dvb.c
+++ b/drivers/media/video/cx88/cx88-dvb.c
@@ -133,6 +133,7 @@ static int cx88_dvb_bus_ctrl(struct dvb_frontend* fe, int acquire)
                 return -EINVAL;
         }
 
+        mutex_lock(&dev->core->lock);
         drv = cx8802_get_driver(dev, CX88_MPEG_DVB);
         if (drv) {
                 if (acquire){
@@ -143,6 +144,7 @@ static int cx88_dvb_bus_ctrl(struct dvb_frontend* fe, int acquire)
                         dev->frontends.active_fe_id = 0;
                 }
         }
+        mutex_unlock(&dev->core->lock);
 
         return ret;
 }
diff --git a/drivers/media/video/cx88/cx88-mpeg.c b/drivers/media/video/cx88/cx88-mpeg.c
index addf9545e9bf..1a7b983f8297 100644
--- a/drivers/media/video/cx88/cx88-mpeg.c
+++ b/drivers/media/video/cx88/cx88-mpeg.c
@@ -78,6 +78,7 @@ static void flush_request_modules(struct cx8802_dev *dev)
 
 
 static LIST_HEAD(cx8802_devlist);
+static DEFINE_MUTEX(cx8802_mutex);
 /* ------------------------------------------------------------------ */
 
 static int cx8802_start_dma(struct cx8802_dev    *dev,
@@ -474,7 +475,7 @@ static int cx8802_init_common(struct cx8802_dev *dev)
                 return -EIO;
         }
 
-        pci_read_config_byte(dev->pci, PCI_CLASS_REVISION, &dev->pci_rev);
+        dev->pci_rev = dev->pci->revision;
         pci_read_config_byte(dev->pci, PCI_LATENCY_TIMER,  &dev->pci_lat);
         printk(KERN_INFO "%s/2: found at %s, rev: %d, irq: %d, "
                "latency: %d, mmio: 0x%llx\n", dev->core->name,
@@ -624,13 +625,11 @@ static int cx8802_request_acquire(struct cx8802_driver *drv)
 
         if (drv->advise_acquire)
         {
-                mutex_lock(&drv->core->lock);
                 core->active_ref++;
                 if (core->active_type_id == CX88_BOARD_NONE) {
                         core->active_type_id = drv->type_id;
                         drv->advise_acquire(drv);
                 }
-                mutex_unlock(&drv->core->lock);
 
                 mpeg_dbg(1,"%s() Post acquire GPIO=%x\n", __func__, cx_read(MO_GP0_IO));
         }
@@ -643,14 +642,12 @@ static int cx8802_request_release(struct cx8802_driver *drv)
 {
         struct cx88_core *core = drv->core;
 
-        mutex_lock(&drv->core->lock);
         if (drv->advise_release && --core->active_ref == 0)
         {
                 drv->advise_release(drv);
                 core->active_type_id = CX88_BOARD_NONE;
                 mpeg_dbg(1,"%s() Post release GPIO=%x\n", __func__, cx_read(MO_GP0_IO));
         }
-        mutex_unlock(&drv->core->lock);
 
         return 0;
 }
@@ -693,6 +690,8 @@ int cx8802_register_driver(struct cx8802_driver *drv)
                 return err;
         }
 
+        mutex_lock(&cx8802_mutex);
+
         list_for_each_entry(dev, &cx8802_devlist, devlist) {
                 printk(KERN_INFO
                        "%s/2: subsystem: %04x:%04x, board: %s [card=%d]\n",
@@ -702,8 +701,10 @@ int cx8802_register_driver(struct cx8802_driver *drv)
 
                 /* Bring up a new struct for each driver instance */
                 driver = kzalloc(sizeof(*drv),GFP_KERNEL);
-                if (driver == NULL)
-                        return -ENOMEM;
+                if (driver == NULL) {
+                        err = -ENOMEM;
+                        goto out;
+                }
 
                 /* Snapshot of the driver registration data */
                 drv->core = dev->core;
@@ -713,21 +714,23 @@ int cx8802_register_driver(struct cx8802_driver *drv)
                 drv->request_release = cx8802_request_release;
                 memcpy(driver, drv, sizeof(*driver));
 
+                mutex_lock(&drv->core->lock);
                 err = drv->probe(driver);
                 if (err == 0) {
                         i++;
-                        mutex_lock(&drv->core->lock);
                         list_add_tail(&driver->drvlist, &dev->drvlist);
-                        mutex_unlock(&drv->core->lock);
                 } else {
                         printk(KERN_ERR
                                "%s/2: cx8802 probe failed, err = %d\n",
                                dev->core->name, err);
                 }
-
+                mutex_unlock(&drv->core->lock);
         }
 
-        return i ? 0 : -ENODEV;
+        err = i ? 0 : -ENODEV;
+out:
+        mutex_unlock(&cx8802_mutex);
+        return err;
 }
 
 int cx8802_unregister_driver(struct cx8802_driver *drv)
@@ -741,6 +744,8 @@ int cx8802_unregister_driver(struct cx8802_driver *drv)
                drv->type_id == CX88_MPEG_DVB ? "dvb" : "blackbird",
                drv->hw_access == CX8802_DRVCTL_SHARED ? "shared" : "exclusive");
 
+        mutex_lock(&cx8802_mutex);
+
         list_for_each_entry(dev, &cx8802_devlist, devlist) {
                 printk(KERN_INFO
                        "%s/2: subsystem: %04x:%04x, board: %s [card=%d]\n",
@@ -748,6 +753,8 @@ int cx8802_unregister_driver(struct cx8802_driver *drv)
                        dev->pci->subsystem_device, dev->core->board.name,
                        dev->core->boardnr);
 
+                mutex_lock(&dev->core->lock);
+
                 list_for_each_entry_safe(d, dtmp, &dev->drvlist, drvlist) {
                         /* only unregister the correct driver type */
                         if (d->type_id != drv->type_id)
@@ -755,17 +762,18 @@ int cx8802_unregister_driver(struct cx8802_driver *drv)
 
                         err = d->remove(d);
                         if (err == 0) {
-                                mutex_lock(&drv->core->lock);
                                 list_del(&d->drvlist);
-                                mutex_unlock(&drv->core->lock);
                                 kfree(d);
                         } else
                                 printk(KERN_ERR "%s/2: cx8802 driver remove "
                                        "failed (%d)\n", dev->core->name, err);
                 }
 
+                mutex_unlock(&dev->core->lock);
         }
 
+        mutex_unlock(&cx8802_mutex);
+
         return err;
 }
 
@@ -803,7 +811,9 @@ static int __devinit cx8802_probe(struct pci_dev *pci_dev,
                 goto fail_free;
 
         INIT_LIST_HEAD(&dev->drvlist);
+        mutex_lock(&cx8802_mutex);
         list_add_tail(&dev->devlist,&cx8802_devlist);
+        mutex_unlock(&cx8802_mutex);
 
         /* now autoload cx88-dvb or cx88-blackbird */
         request_modules(dev);
@@ -827,6 +837,8 @@ static void __devexit cx8802_remove(struct pci_dev *pci_dev)
 
         flush_request_modules(dev);
 
+        mutex_lock(&dev->core->lock);
+
         if (!list_empty(&dev->drvlist)) {
                 struct cx8802_driver *drv, *tmp;
                 int err;
@@ -838,9 +850,7 @@ static void __devexit cx8802_remove(struct pci_dev *pci_dev)
                 list_for_each_entry_safe(drv, tmp, &dev->drvlist, drvlist) {
                         err = drv->remove(drv);
                         if (err == 0) {
-                                mutex_lock(&drv->core->lock);
                                 list_del(&drv->drvlist);
-                                mutex_unlock(&drv->core->lock);
                         } else
                                 printk(KERN_ERR "%s/2: cx8802 driver remove "
                                        "failed (%d)\n", dev->core->name, err);
@@ -848,6 +858,8 @@ static void __devexit cx8802_remove(struct pci_dev *pci_dev)
                 }
         }
 
+        mutex_unlock(&dev->core->lock);
+
         /* Destroy any 8802 reference. */
         dev->core->dvbdev = NULL;
 
diff --git a/drivers/media/video/cx88/cx88-video.c b/drivers/media/video/cx88/cx88-video.c
index 287a41ee1c4f..cef4f282e5aa 100644
--- a/drivers/media/video/cx88/cx88-video.c
+++ b/drivers/media/video/cx88/cx88-video.c
@@ -824,7 +824,7 @@ static int video_open(struct file *file)
                 call_all(core, tuner, s_radio);
         }
 
-        atomic_inc(&core->users);
+        core->users++;
         mutex_unlock(&core->lock);
 
         return 0;
@@ -922,7 +922,8 @@ static int video_release(struct file *file)
         file->private_data = NULL;
         kfree(fh);
 
-        if(atomic_dec_and_test(&dev->core->users))
+        dev->core->users--;
+        if (!dev->core->users)
                 call_all(dev->core, core, s_power, 0);
         mutex_unlock(&dev->core->lock);
 
@@ -1832,7 +1833,7 @@ static int __devinit cx8800_initdev(struct pci_dev *pci_dev,
         dev->core = core;
 
         /* print pci info */
-        pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &dev->pci_rev);
+        dev->pci_rev = pci_dev->revision;
         pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER,  &dev->pci_lat);
         printk(KERN_INFO "%s/0: found at %s, rev: %d, irq: %d, "
                "latency: %d, mmio: 0x%llx\n", core->name,
diff --git a/drivers/media/video/cx88/cx88.h b/drivers/media/video/cx88/cx88.h
index 9b3742a7746c..a399a8b086ba 100644
--- a/drivers/media/video/cx88/cx88.h
+++ b/drivers/media/video/cx88/cx88.h
@@ -389,8 +389,8 @@ struct cx88_core {
         struct mutex               lock;
         /* various v4l controls */
         u32                        freq;
-        atomic_t                   users;
-        atomic_t                   mpeg_users;
+        int                        users;
+        int                        mpeg_users;
 
         /* cx88-video needs to access cx8802 for hybrid tuner pll access. */
         struct cx8802_dev          *dvbdev;
@@ -505,6 +505,8 @@ struct cx8802_driver {
         int (*suspend)(struct pci_dev *pci_dev, pm_message_t state);
         int (*resume)(struct pci_dev *pci_dev);
 
+        /* Callers to the following functions must hold core->lock */
+
         /* MPEG 8802 -> mini driver - Driver probe and configuration */
         int (*probe)(struct cx8802_driver *drv);
         int (*remove)(struct cx8802_driver *drv);
@@ -561,8 +563,9 @@ struct cx8802_dev {
         /* for switching modulation types */
         unsigned char              ts_gen_cntrl;
 
-        /* List of attached drivers */
+        /* List of attached drivers; must hold core->lock to access */
         struct list_head           drvlist;
+
         struct work_struct         request_module_wk;
 };
 
@@ -685,6 +688,8 @@ int cx88_audio_thread(void *data);
 
 int cx8802_register_driver(struct cx8802_driver *drv);
 int cx8802_unregister_driver(struct cx8802_driver *drv);
+
+/* Caller must hold core->lock */
 struct cx8802_driver * cx8802_get_driver(struct cx8802_dev *dev, enum cx88_board_type btype);
 
 /* ----------------------------------------------------------- */