Revert "OMAPFB: simplify locking"

This reverts commit b41deecbda70067b26a3a7704fdf967a7940935b.

The simpler locking causes huge latencies when two processes use the
omapfb, even if they use different framebuffers.

Signed-off-by: Tomi Valkeinen <[e-mail]>

drivers/video/omap2/omapfb/omapfb-ioctl.c

···
 		goto out;
 	}
 
+	/* Take the locks in a specific order to keep lockdep happy */
+	if (old_rg->id < new_rg->id) {
+		omapfb_get_mem_region(old_rg);
+		omapfb_get_mem_region(new_rg);
+	} else if (new_rg->id < old_rg->id) {
+		omapfb_get_mem_region(new_rg);
+		omapfb_get_mem_region(old_rg);
+	} else
+		omapfb_get_mem_region(old_rg);
+
 	if (pi->enabled && !new_rg->size) {
 		/*
 		 * This plane's memory was freed, can't enable it
···
 			goto undo;
 	}
 
+	/* Release the locks in a specific order to keep lockdep happy */
+	if (old_rg->id > new_rg->id) {
+		omapfb_put_mem_region(old_rg);
+		omapfb_put_mem_region(new_rg);
+	} else if (new_rg->id > old_rg->id) {
+		omapfb_put_mem_region(new_rg);
+		omapfb_put_mem_region(old_rg);
+	} else
+		omapfb_put_mem_region(old_rg);
+
 	return 0;
 
  undo:
···
 
 	ovl->set_overlay_info(ovl, &old_info);
  put_mem:
+	/* Release the locks in a specific order to keep lockdep happy */
+	if (old_rg->id > new_rg->id) {
+		omapfb_put_mem_region(old_rg);
+		omapfb_put_mem_region(new_rg);
+	} else if (new_rg->id > old_rg->id) {
+		omapfb_put_mem_region(new_rg);
+		omapfb_put_mem_region(old_rg);
+	} else
+		omapfb_put_mem_region(old_rg);
  out:
 	dev_err(fbdev->dev, "setup_plane failed\n");
 
···
 	if (display && display->driver->sync)
 		display->driver->sync(display);
 
-	mutex_lock(&fbi->mm_lock);
-
 	rg = ofbi->region;
+
+	down_write_nested(&rg->lock, rg->id);
+	atomic_inc(&rg->lock_count);
 
 	if (rg->size == size && rg->type == mi->type)
 		goto out;
···
 	}
 
  out:
-	mutex_unlock(&fbi->mm_lock);
+	atomic_dec(&rg->lock_count);
+	up_write(&rg->lock);
+
 	return r;
 }
 
···
 	struct omapfb_info *ofbi = FB2OFB(fbi);
 	struct omapfb2_mem_region *rg;
 
-	rg = ofbi->region;
+	rg = omapfb_get_mem_region(ofbi->region);
 	memset(mi, 0, sizeof(*mi));
 
 	mi->size = rg->size;
 	mi->type = rg->type;
+
+	omapfb_put_mem_region(rg);
 
 	return 0;
 }
···
 	if (mode != OMAPFB_AUTO_UPDATE && mode != OMAPFB_MANUAL_UPDATE)
 		return -EINVAL;
 
+	omapfb_lock(fbdev);
+
 	d = get_display_data(fbdev, display);
 
-	if (d->update_mode == mode)
+	if (d->update_mode == mode) {
+		omapfb_unlock(fbdev);
 		return 0;
+	}
 
 	r = 0;
 
···
 			r = -EINVAL;
 	}
 
+	omapfb_unlock(fbdev);
+
 	return r;
 }
 
···
 	if (!display)
 		return -EINVAL;
 
+	omapfb_lock(fbdev);
+
 	d = get_display_data(fbdev, display);
 
 	*mode = d->update_mode;
+
+	omapfb_unlock(fbdev);
 
 	return 0;
 }
···
 		struct omapfb_color_key *ck)
 {
 	struct omapfb_info *ofbi = FB2OFB(fbi);
+	struct omapfb2_device *fbdev = ofbi->fbdev;
 	int r;
 	int i;
 	struct omap_overlay_manager *mgr = NULL;
+
+	omapfb_lock(fbdev);
 
 	for (i = 0; i < ofbi->num_overlays; i++) {
 		if (ofbi->overlays[i]->manager) {
···
 
 	r = _omapfb_set_color_key(mgr, ck);
 err:
+	omapfb_unlock(fbdev);
+
 	return r;
 }
 
···
 		struct omapfb_color_key *ck)
 {
 	struct omapfb_info *ofbi = FB2OFB(fbi);
+	struct omapfb2_device *fbdev = ofbi->fbdev;
 	struct omap_overlay_manager *mgr = NULL;
 	int r = 0;
 	int i;
+
+	omapfb_lock(fbdev);
 
 	for (i = 0; i < ofbi->num_overlays; i++) {
 		if (ofbi->overlays[i]->manager) {
···
 
 	*ck = omapfb_color_keys[mgr->id];
 err:
+	omapfb_unlock(fbdev);
+
 	return r;
 }
 
···
 	} p;
 
 	int r = 0;
-
-	omapfb_lock(fbdev);
 
 	switch (cmd) {
 	case OMAPFB_SYNC_GFX:
···
 		dev_err(fbdev->dev, "Unknown ioctl 0x%x\n", cmd);
 		r = -EINVAL;
 	}
-
-	omapfb_unlock(fbdev);
 
 	if (r < 0)
 		DBG("ioctl failed: %d\n", r);

drivers/video/omap2/omapfb/omapfb-main.c

···
 
 	DBG("check_fb_var %d\n", ofbi->id);
 
+	WARN_ON(!atomic_read(&ofbi->region->lock_count));
+
 	r = fb_mode_to_dss_mode(var, &mode);
 	if (r) {
 		DBG("cannot convert var to omap dss mode\n");
···
 	int rotation = var->rotate;
 	int i;
 
+	WARN_ON(!atomic_read(&ofbi->region->lock_count));
+
 	for (i = 0; i < ofbi->num_overlays; i++) {
 		if (ovl != ofbi->overlays[i])
 			continue;
···
 		fill_fb(fbi);
 #endif
 
+	WARN_ON(!atomic_read(&ofbi->region->lock_count));
+
 	for (i = 0; i < ofbi->num_overlays; i++) {
 		ovl = ofbi->overlays[i];
 
···
 static int omapfb_check_var(struct fb_var_screeninfo *var, struct fb_info *fbi)
 {
 	struct omapfb_info *ofbi = FB2OFB(fbi);
-	struct omapfb2_device *fbdev = ofbi->fbdev;
 	int r;
 
 	DBG("check_var(%d)\n", FB2OFB(fbi)->id);
 
-	omapfb_lock(fbdev);
+	omapfb_get_mem_region(ofbi->region);
 
 	r = check_fb_var(fbi, var);
 
-	omapfb_unlock(fbdev);
+	omapfb_put_mem_region(ofbi->region);
 
 	return r;
 }
···
 static int omapfb_set_par(struct fb_info *fbi)
 {
 	struct omapfb_info *ofbi = FB2OFB(fbi);
-	struct omapfb2_device *fbdev = ofbi->fbdev;
 	int r;
 
 	DBG("set_par(%d)\n", FB2OFB(fbi)->id);
 
-	omapfb_lock(fbdev);
+	omapfb_get_mem_region(ofbi->region);
 
 	set_fb_fix(fbi);
 
···
 	r = omapfb_apply_changes(fbi, 0);
 
  out:
-	omapfb_unlock(fbdev);
+	omapfb_put_mem_region(ofbi->region);
 
 	return r;
 }
···
 		struct fb_info *fbi)
 {
 	struct omapfb_info *ofbi = FB2OFB(fbi);
-	struct omapfb2_device *fbdev = ofbi->fbdev;
 	struct fb_var_screeninfo new_var;
 	int r;
 
···
 
 	fbi->var = new_var;
 
-	omapfb_lock(fbdev);
+	omapfb_get_mem_region(ofbi->region);
 
 	r = omapfb_apply_changes(fbi, 0);
 
-	omapfb_unlock(fbdev);
+	omapfb_put_mem_region(ofbi->region);
 
 	return r;
 }
···
 {
 	struct omapfb2_mem_region *rg = vma->vm_private_data;
 
+	omapfb_get_mem_region(rg);
 	atomic_inc(&rg->map_count);
+	omapfb_put_mem_region(rg);
 }
 
 static void mmap_user_close(struct vm_area_struct *vma)
 {
 	struct omapfb2_mem_region *rg = vma->vm_private_data;
 
+	omapfb_get_mem_region(rg);
 	atomic_dec(&rg->map_count);
+	omapfb_put_mem_region(rg);
 }
 
 static struct vm_operations_struct mmap_user_ops = {
···
 		return -EINVAL;
 	off = vma->vm_pgoff << PAGE_SHIFT;
 
-	rg = ofbi->region;
+	rg = omapfb_get_mem_region(ofbi->region);
 
 	start = omapfb_get_region_paddr(ofbi);
 	len = fix->smem_len;
···
 	/* vm_ops.open won't be called for mmap itself. */
 	atomic_inc(&rg->map_count);
 
+	omapfb_put_mem_region(rg);
+
 	return 0;
 
  error:
+	omapfb_put_mem_region(ofbi->region);
+
 	return r;
 }
 
···
 
 		ofbi->region = &fbdev->regions[i];
 		ofbi->region->id = i;
+		init_rwsem(&ofbi->region->lock);
 
 		/* assign these early, so that fb alloc can use them */
 		ofbi->rotation_type = def_vrfb ? OMAP_DSS_ROT_VRFB :
···
 	/* setup fb_infos */
 	for (i = 0; i < fbdev->num_fbs; i++) {
 		struct fb_info *fbi = fbdev->fbs[i];
+		struct omapfb_info *ofbi = FB2OFB(fbi);
 
+		omapfb_get_mem_region(ofbi->region);
 		r = omapfb_fb_init(fbdev, fbi);
+		omapfb_put_mem_region(ofbi->region);
+
 		if (r) {
 			dev_err(fbdev->dev, "failed to setup fb_info\n");
 			return r;
···
 
 	for (i = 0; i < fbdev->num_fbs; i++) {
 		struct fb_info *fbi = fbdev->fbs[i];
+		struct omapfb_info *ofbi = FB2OFB(fbi);
 
+		omapfb_get_mem_region(ofbi->region);
 		r = omapfb_apply_changes(fbi, 1);
+		omapfb_put_mem_region(ofbi->region);
+
 		if (r) {
 			dev_err(fbdev->dev, "failed to change mode\n");
 			return r;

drivers/video/omap2/omapfb/omapfb-sysfs.c

···
 {
 	struct fb_info *fbi = dev_get_drvdata(dev);
 	struct omapfb_info *ofbi = FB2OFB(fbi);
-	struct omapfb2_device *fbdev = ofbi->fbdev;
 	struct omapfb2_mem_region *rg;
 	int rot_type;
 	int r;
···
 
 	if (!lock_fb_info(fbi))
 		return -ENODEV;
-	omapfb_lock(fbdev);
 
 	r = 0;
 	if (rot_type == ofbi->rotation_type)
 		goto out;
 
-	rg = ofbi->region;
+	rg = omapfb_get_mem_region(ofbi->region);
 
 	if (rg->size) {
 		r = -EBUSY;
···
 	 * need to do any further parameter checking at this point.
 	 */
 put_region:
+	omapfb_put_mem_region(rg);
 out:
-	omapfb_unlock(fbdev);
 	unlock_fb_info(fbi);
 
 	return r ? r : count;
···
 {
 	struct fb_info *fbi = dev_get_drvdata(dev);
 	struct omapfb_info *ofbi = FB2OFB(fbi);
-	struct omapfb2_device *fbdev = ofbi->fbdev;
 	bool mirror;
 	int r;
 	struct fb_var_screeninfo new_var;
···
 
 	if (!lock_fb_info(fbi))
 		return -ENODEV;
-	omapfb_lock(fbdev);
 
 	ofbi->mirror = mirror;
+
+	omapfb_get_mem_region(ofbi->region);
 
 	memcpy(&new_var, &fbi->var, sizeof(new_var));
 	r = check_fb_var(fbi, &new_var);
···
 
 	r = count;
 out:
-	omapfb_unlock(fbdev);
+	omapfb_put_mem_region(ofbi->region);
+
 	unlock_fb_info(fbi);
 
 	return r;
···
 
 		DBG("detaching %d\n", ofbi->overlays[i]->id);
 
+		omapfb_get_mem_region(ofbi->region);
+
 		omapfb_overlay_enable(ovl, 0);
 
 		if (ovl->manager)
 			ovl->manager->apply(ovl->manager);
+
+		omapfb_put_mem_region(ofbi->region);
 
 		for (t = i + 1; t < ofbi->num_overlays; t++) {
 			ofbi->rotation[t-1] = ofbi->rotation[t];
···
 	}
 
 	if (added) {
+		omapfb_get_mem_region(ofbi->region);
+
 		r = omapfb_apply_changes(fbi, 0);
+
+		omapfb_put_mem_region(ofbi->region);
 
 		if (r)
 			goto out;
···
 {
 	struct fb_info *fbi = dev_get_drvdata(dev);
 	struct omapfb_info *ofbi = FB2OFB(fbi);
-	struct omapfb2_device *fbdev = ofbi->fbdev;
 	ssize_t l = 0;
 	int t;
 
 	if (!lock_fb_info(fbi))
 		return -ENODEV;
-	omapfb_lock(fbdev);
 
 	for (t = 0; t < ofbi->num_overlays; t++) {
 		l += snprintf(buf + l, PAGE_SIZE - l, "%s%d",
···
 
 	l += snprintf(buf + l, PAGE_SIZE - l, "\n");
 
-	omapfb_unlock(fbdev);
 	unlock_fb_info(fbi);
 
 	return l;
···
 {
 	struct fb_info *fbi = dev_get_drvdata(dev);
 	struct omapfb_info *ofbi = FB2OFB(fbi);
-	struct omapfb2_device *fbdev = ofbi->fbdev;
 	int num_ovls = 0, r, i;
 	int len;
 	bool changed = false;
···
 
 	if (!lock_fb_info(fbi))
 		return -ENODEV;
-	omapfb_lock(fbdev);
 
 	if (len > 0) {
 		char *p = (char *)buf;
···
 		for (i = 0; i < num_ovls; ++i)
 			ofbi->rotation[i] = rotation[i];
 
+		omapfb_get_mem_region(ofbi->region);
+
 		r = omapfb_apply_changes(fbi, 0);
+
+		omapfb_put_mem_region(ofbi->region);
+
 		if (r)
 			goto out;
 
···
 
 	r = count;
 out:
-	omapfb_unlock(fbdev);
 	unlock_fb_info(fbi);
 
 	return r;
···
 {
 	struct fb_info *fbi = dev_get_drvdata(dev);
 	struct omapfb_info *ofbi = FB2OFB(fbi);
-	struct omapfb2_device *fbdev = ofbi->fbdev;
-	int r;
 
-	if (!lock_fb_info(fbi))
-		return -ENODEV;
-	omapfb_lock(fbdev);
-
-	r = snprintf(buf, PAGE_SIZE, "%lu\n", ofbi->region->size);
-
-	omapfb_unlock(fbdev);
-	unlock_fb_info(fbi);
-
-	return r;
+	return snprintf(buf, PAGE_SIZE, "%lu\n", ofbi->region->size);
 }
 
 static ssize_t store_size(struct device *dev, struct device_attribute *attr,
···
 
 	if (!lock_fb_info(fbi))
 		return -ENODEV;
-	omapfb_lock(fbdev);
 
 	if (display && display->driver->sync)
 		display->driver->sync(display);
 
-	mutex_lock(&fbi->mm_lock);
-
 	rg = ofbi->region;
+
+	down_write_nested(&rg->lock, rg->id);
+	atomic_inc(&rg->lock_count);
 
 	if (atomic_read(&rg->map_count)) {
 		r = -EBUSY;
···
 
 	r = count;
 out:
-	mutex_unlock(&fbi->mm_lock);
-	omapfb_unlock(fbdev);
+	atomic_dec(&rg->lock_count);
+	up_write(&rg->lock);
+
 	unlock_fb_info(fbi);
 
 	return r;
···
 {
 	struct fb_info *fbi = dev_get_drvdata(dev);
 	struct omapfb_info *ofbi = FB2OFB(fbi);
-	struct omapfb2_device *fbdev = ofbi->fbdev;
-	int r;
 
-	if (!lock_fb_info(fbi))
-		return -ENODEV;
-	omapfb_lock(fbdev);
-
-	r = snprintf(buf, PAGE_SIZE, "%0x\n", ofbi->region->paddr);
-
-	omapfb_unlock(fbdev);
-	unlock_fb_info(fbi);
-
-	return r;
+	return snprintf(buf, PAGE_SIZE, "%0x\n", ofbi->region->paddr);
 }
 
 static ssize_t show_virt(struct device *dev,
···
 		struct device_attribute *attr, char *buf)
 {
 	struct fb_info *fbi = dev_get_drvdata(dev);
-	struct omapfb_info *ofbi = FB2OFB(fbi);
-	struct omapfb2_device *fbdev = ofbi->fbdev;
 	enum omapfb_update_mode mode;
 	int r;
 
-	if (!lock_fb_info(fbi))
-		return -ENODEV;
-	omapfb_lock(fbdev);
-
 	r = omapfb_get_update_mode(fbi, &mode);
-
-	omapfb_unlock(fbdev);
-	unlock_fb_info(fbi);
 
 	if (r)
 		return r;
···
 		const char *buf, size_t count)
 {
 	struct fb_info *fbi = dev_get_drvdata(dev);
-	struct omapfb_info *ofbi = FB2OFB(fbi);
-	struct omapfb2_device *fbdev = ofbi->fbdev;
 	unsigned mode;
 	int r;
 
···
 	if (r)
 		return r;
 
-	if (!lock_fb_info(fbi))
-		return -ENODEV;
-	omapfb_lock(fbdev);
-
 	r = omapfb_set_update_mode(fbi, mode);
 	if (r)
 		return r;
-
-	omapfb_unlock(fbdev);
-	unlock_fb_info(fbi);
 
 	return count;
 }

drivers/video/omap2/omapfb/omapfb.h

···
 	bool		alloc;		/* allocated by the driver */
 	bool		map;		/* kernel mapped by the driver */
 	atomic_t	map_count;
+	struct rw_semaphore lock;
+	atomic_t	lock_count;
 };
 
 /* appended to fb_info */
···
 		return ovl->enable(ovl);
 	else
 		return ovl->disable(ovl);
+}
+
+static inline struct omapfb2_mem_region *
+omapfb_get_mem_region(struct omapfb2_mem_region *rg)
+{
+	down_read_nested(&rg->lock, rg->id);
+	atomic_inc(&rg->lock_count);
+	return rg;
+}
+
+static inline void omapfb_put_mem_region(struct omapfb2_mem_region *rg)
+{
+	atomic_dec(&rg->lock_count);
+	up_read(&rg->lock);
 }
 
 #endif