Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit c354a864 authored by Paul Walmsley's avatar Paul Walmsley
Browse files

W1: OMAP HDQ1W: use runtime PM



Convert the OMAP HDQ driver to use runtime PM.  Compile- and boot-tested,
but not tested in actual use.

Signed-off-by: default avatarPaul Walmsley <paul@pwsan.com>
Cc: NeilBrown <neilb@suse.de>
Cc: Evgeniy Polyakov <zbr@ioremap.net>
Acked-by: default avatarEvgeniy Polyakov <zbr@ioremap.net>
Tested-by: default avatarNeilBrown <neilb@suse.de>
parent 96b1b29d
Loading
Loading
Loading
Loading
+13 −65
Original line number Original line Diff line number Diff line
/*
/*
 * drivers/w1/masters/omap_hdq.c
 * drivers/w1/masters/omap_hdq.c
 *
 *
 * Copyright (C) 2007 Texas Instruments, Inc.
 * Copyright (C) 2007,2012 Texas Instruments, Inc.
 *
 *
 * This file is licensed under the terms of the GNU General Public License
 * This file is licensed under the terms of the GNU General Public License
 * version 2. This program is licensed "as is" without any warranty of any
 * version 2. This program is licensed "as is" without any warranty of any
@@ -14,9 +14,9 @@
#include <linux/interrupt.h>
#include <linux/interrupt.h>
#include <linux/slab.h>
#include <linux/slab.h>
#include <linux/err.h>
#include <linux/err.h>
#include <linux/clk.h>
#include <linux/io.h>
#include <linux/io.h>
#include <linux/sched.h>
#include <linux/sched.h>
#include <linux/pm_runtime.h>


#include <asm/irq.h>
#include <asm/irq.h>
#include <mach/hardware.h>
#include <mach/hardware.h>
@@ -61,8 +61,6 @@ struct hdq_data {
	/* lock status update */
	/* lock status update */
	struct  mutex		hdq_mutex;
	struct  mutex		hdq_mutex;
	int			hdq_usecount;
	int			hdq_usecount;
	struct	clk		*hdq_ick;
	struct	clk		*hdq_fck;
	u8			hdq_irqstatus;
	u8			hdq_irqstatus;
	/* device lock */
	/* device lock */
	spinlock_t		hdq_spinlock;
	spinlock_t		hdq_spinlock;
@@ -419,17 +417,8 @@ static int omap_hdq_get(struct hdq_data *hdq_data)
		hdq_data->hdq_usecount++;
		hdq_data->hdq_usecount++;
		try_module_get(THIS_MODULE);
		try_module_get(THIS_MODULE);
		if (1 == hdq_data->hdq_usecount) {
		if (1 == hdq_data->hdq_usecount) {
			if (clk_enable(hdq_data->hdq_ick)) {

				dev_dbg(hdq_data->dev, "Can not enable ick\n");
			pm_runtime_get_sync(hdq_data->dev);
				ret = -ENODEV;
				goto clk_err;
			}
			if (clk_enable(hdq_data->hdq_fck)) {
				dev_dbg(hdq_data->dev, "Can not enable fck\n");
				clk_disable(hdq_data->hdq_ick);
				ret = -ENODEV;
				goto clk_err;
			}


			/* make sure HDQ is out of reset */
			/* make sure HDQ is out of reset */
			if (!(hdq_reg_in(hdq_data, OMAP_HDQ_SYSSTATUS) &
			if (!(hdq_reg_in(hdq_data, OMAP_HDQ_SYSSTATUS) &
@@ -450,9 +439,6 @@ static int omap_hdq_get(struct hdq_data *hdq_data)
		}
		}
	}
	}


clk_err:
	clk_put(hdq_data->hdq_ick);
	clk_put(hdq_data->hdq_fck);
out:
out:
	mutex_unlock(&hdq_data->hdq_mutex);
	mutex_unlock(&hdq_data->hdq_mutex);
rtn:
rtn:
@@ -475,10 +461,8 @@ static int omap_hdq_put(struct hdq_data *hdq_data)
	} else {
	} else {
		hdq_data->hdq_usecount--;
		hdq_data->hdq_usecount--;
		module_put(THIS_MODULE);
		module_put(THIS_MODULE);
		if (0 == hdq_data->hdq_usecount) {
		if (0 == hdq_data->hdq_usecount)
			clk_disable(hdq_data->hdq_ick);
			pm_runtime_put_sync(hdq_data->dev);
			clk_disable(hdq_data->hdq_fck);
		}
	}
	}
	mutex_unlock(&hdq_data->hdq_mutex);
	mutex_unlock(&hdq_data->hdq_mutex);


@@ -591,35 +575,11 @@ static int __devinit omap_hdq_probe(struct platform_device *pdev)
		goto err_ioremap;
		goto err_ioremap;
	}
	}


	/* get interface & functional clock objects */
	hdq_data->hdq_ick = clk_get(&pdev->dev, "ick");
	if (IS_ERR(hdq_data->hdq_ick)) {
		dev_dbg(&pdev->dev, "Can't get HDQ ick clock object\n");
		ret = PTR_ERR(hdq_data->hdq_ick);
		goto err_ick;
	}

	hdq_data->hdq_fck = clk_get(&pdev->dev, "fck");
	if (IS_ERR(hdq_data->hdq_fck)) {
		dev_dbg(&pdev->dev, "Can't get HDQ fck clock object\n");
		ret = PTR_ERR(hdq_data->hdq_fck);
		goto err_fck;
	}

	hdq_data->hdq_usecount = 0;
	hdq_data->hdq_usecount = 0;
	mutex_init(&hdq_data->hdq_mutex);
	mutex_init(&hdq_data->hdq_mutex);


	if (clk_enable(hdq_data->hdq_ick)) {
	pm_runtime_enable(&pdev->dev);
		dev_dbg(&pdev->dev, "Can not enable ick\n");
	pm_runtime_get_sync(&pdev->dev);
		ret = -ENODEV;
		goto err_intfclk;
	}

	if (clk_enable(hdq_data->hdq_fck)) {
		dev_dbg(&pdev->dev, "Can not enable fck\n");
		ret = -ENODEV;
		goto err_fnclk;
	}


	rev = hdq_reg_in(hdq_data, OMAP_HDQ_REVISION);
	rev = hdq_reg_in(hdq_data, OMAP_HDQ_REVISION);
	dev_info(&pdev->dev, "OMAP HDQ Hardware Rev %c.%c. Driver in %s mode\n",
	dev_info(&pdev->dev, "OMAP HDQ Hardware Rev %c.%c. Driver in %s mode\n",
@@ -641,9 +601,7 @@ static int __devinit omap_hdq_probe(struct platform_device *pdev)


	omap_hdq_break(hdq_data);
	omap_hdq_break(hdq_data);


	/* don't clock the HDQ until it is needed */
	pm_runtime_put_sync(&pdev->dev);
	clk_disable(hdq_data->hdq_ick);
	clk_disable(hdq_data->hdq_fck);


	omap_w1_master.data = hdq_data;
	omap_w1_master.data = hdq_data;


@@ -655,20 +613,11 @@ static int __devinit omap_hdq_probe(struct platform_device *pdev)


	return 0;
	return 0;


err_w1:
err_irq:
err_irq:
	clk_disable(hdq_data->hdq_fck);
	pm_runtime_put_sync(&pdev->dev);

err_w1:
err_fnclk:
	pm_runtime_disable(&pdev->dev);
	clk_disable(hdq_data->hdq_ick);

err_intfclk:
	clk_put(hdq_data->hdq_fck);

err_fck:
	clk_put(hdq_data->hdq_ick);


err_ick:
	iounmap(hdq_data->hdq_base);
	iounmap(hdq_data->hdq_base);


err_ioremap:
err_ioremap:
@@ -696,8 +645,7 @@ static int omap_hdq_remove(struct platform_device *pdev)
	mutex_unlock(&hdq_data->hdq_mutex);
	mutex_unlock(&hdq_data->hdq_mutex);


	/* remove module dependency */
	/* remove module dependency */
	clk_put(hdq_data->hdq_ick);
	pm_runtime_disable(&pdev->dev);
	clk_put(hdq_data->hdq_fck);
	free_irq(INT_24XX_HDQ_IRQ, hdq_data);
	free_irq(INT_24XX_HDQ_IRQ, hdq_data);
	platform_set_drvdata(pdev, NULL);
	platform_set_drvdata(pdev, NULL);
	iounmap(hdq_data->hdq_base);
	iounmap(hdq_data->hdq_base);