From patchwork Tue Dec 4 10:42:15 2012 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Guennadi Liakhovetski X-Patchwork-Id: 1837091 Return-Path: X-Original-To: patchwork-linux-media@patchwork.kernel.org Delivered-To: patchwork-process-083081@patchwork1.kernel.org Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by patchwork1.kernel.org (Postfix) with ESMTP id 446AB3FCA5 for ; Tue, 4 Dec 2012 10:42:27 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752813Ab2LDKmY (ORCPT ); Tue, 4 Dec 2012 05:42:24 -0500 Received: from moutng.kundenserver.de ([212.227.126.186]:52355 "EHLO moutng.kundenserver.de" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751452Ab2LDKmX (ORCPT ); Tue, 4 Dec 2012 05:42:23 -0500 Received: from axis700.grange (dslb-094-221-109-052.pools.arcor-ip.net [94.221.109.52]) by mrelayeu.kundenserver.de (node=mreu1) with ESMTP (Nemesis) id 0Mefts-1Tql8Z2zhA-00OvEF; Tue, 04 Dec 2012 11:42:17 +0100 Received: by axis700.grange (Postfix, from userid 1000) id 36E55105E7; Tue, 4 Dec 2012 11:42:15 +0100 (CET) Received: from localhost (localhost [127.0.0.1]) by axis700.grange (Postfix) with ESMTP id 2A54940B98; Tue, 4 Dec 2012 11:42:15 +0100 (CET) Date: Tue, 4 Dec 2012 11:42:15 +0100 (CET) From: Guennadi Liakhovetski X-X-Sender: lyakh@axis700.grange To: Linux Media Mailing List cc: Laurent Pinchart , Sakari Ailus , Sylwester Nawrocki , Hans Verkuil , Sylwester Nawrocki , Magnus Damm , linux-sh@vger.kernel.org Subject: [PATCH v3] media: V4L2: add temporary clock helpers Message-ID: MIME-Version: 1.0 X-Provags-ID: V02:K0:fIneknJmz+/tDN3igg0SgzCaTJ3LhBT25Aj/Q9OaDZH 9W9AhF16mug1UOlJSW1q58qnuU7QbYu42gSjWcB27OGG1YUj5X hcm96SBT7U+5ZpOOLbu481CgDmgLAjyuP8zm3YEOdKRFx29Y6m tanBDzx+qiWReU+2FTLJ0Sd/b+v/gcYFyXfLRBh0h6GAppB0Yy YTYm24VC8Zzw9EyfmWFSZcAWFeF2vldsEjA/bSHzvnfvQDZkJ8 G4r6IY8mjNNcSfEkJwWzEZK/EPzXldHVrE01jF8nAGip1eYMdC LLeWOsuSElBFtAG4uQ4jzqCP8n3egRuDZ0uV0WSxfMoRSrjLmG HhfQOB1+N5AnMVJfvxJ1IMwMEXwrDvgwHoie02sFsNGaDnw+QC flj0iqTHHAYSQ== Sender: linux-media-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-media@vger.kernel.org Typical video devices like camera sensors require an external clock source. Many such devices cannot even access their hardware registers without a running clock. These clock sources should be controlled by their consumers. This should be performed, using the generic clock framework. Unfortunately so far only very few systems have been ported to that framework. This patch adds a set of temporary helpers, mimicking the generic clock API, to V4L2. Platforms, adopting the clock API, should switch to using it. Eventually this temporary API should be removed. Signed-off-by: Guennadi Liakhovetski --- v3: (thanks for all the comments) 1. add and use a mutex to protect the enable counter instead of an atomic variable 2. add a use-count 3. add "const" to dev_id 4. move allocations outside the mutex 5. allow rate reading and setting on disabled clock 6. rename the clock list head:-) drivers/media/v4l2-core/Makefile | 2 +- drivers/media/v4l2-core/v4l2-clk.c | 176 ++++++++++++++++++++++++++++++++++++ include/media/v4l2-clk.h | 54 +++++++++++ 3 files changed, 231 insertions(+), 1 deletions(-) create mode 100644 drivers/media/v4l2-core/v4l2-clk.c create mode 100644 include/media/v4l2-clk.h diff --git a/drivers/media/v4l2-core/Makefile b/drivers/media/v4l2-core/Makefile index c2d61d4..d065c01 100644 --- a/drivers/media/v4l2-core/Makefile +++ b/drivers/media/v4l2-core/Makefile @@ -5,7 +5,7 @@ tuner-objs := tuner-core.o videodev-objs := v4l2-dev.o v4l2-ioctl.o v4l2-device.o v4l2-fh.o \ - v4l2-event.o v4l2-ctrls.o v4l2-subdev.o + v4l2-event.o v4l2-ctrls.o v4l2-subdev.o v4l2-clk.o ifeq ($(CONFIG_COMPAT),y) videodev-objs += v4l2-compat-ioctl32.o endif diff --git a/drivers/media/v4l2-core/v4l2-clk.c b/drivers/media/v4l2-core/v4l2-clk.c new file mode 100644 index 0000000..2225081 --- /dev/null +++ b/drivers/media/v4l2-core/v4l2-clk.c @@ -0,0 +1,176 @@ +/* + * V4L2 clock service + * + * Copyright (C) 2012, Guennadi Liakhovetski + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ + +#include +#include +#include +#include +#include +#include + +#include +#include + +static DEFINE_MUTEX(clk_lock); +static LIST_HEAD(clk_list); + +static struct v4l2_clk *v4l2_clk_find(const char *dev_id, const char *id) +{ + struct v4l2_clk *clk; + + list_for_each_entry(clk, &clk_list, list) { + if (strcmp(dev_id, clk->dev_id)) + continue; + + if (!id || !clk->id || !strcmp(clk->id, id)) + return clk; + } + + return ERR_PTR(-ENODEV); +} + +struct v4l2_clk *v4l2_clk_get(struct v4l2_subdev *sd, const char *id) +{ + struct v4l2_clk *clk; + + mutex_lock(&clk_lock); + clk = v4l2_clk_find(sd->name, id); + + if (!IS_ERR(clk) && !try_module_get(clk->ops->owner)) + clk = ERR_PTR(-ENODEV); + mutex_unlock(&clk_lock); + + if (!IS_ERR(clk)) + atomic_inc(&clk->use_count); + + return clk; +} +EXPORT_SYMBOL(v4l2_clk_get); + +void v4l2_clk_put(struct v4l2_clk *clk) +{ + if (!IS_ERR(clk)) { + atomic_dec(&clk->use_count); + module_put(clk->ops->owner); + } +} +EXPORT_SYMBOL(v4l2_clk_put); + +int v4l2_clk_enable(struct v4l2_clk *clk) +{ + int ret; + mutex_lock(&clk->lock); + if (++clk->enable == 1 && clk->ops->enable) { + ret = clk->ops->enable(clk); + if (ret < 0) + clk->enable--; + } else { + ret = 0; + } + mutex_unlock(&clk->lock); + return ret; +} +EXPORT_SYMBOL(v4l2_clk_enable); + +void v4l2_clk_disable(struct v4l2_clk *clk) +{ + int enable; + + mutex_lock(&clk->lock); + enable = --clk->enable; + if (WARN(enable < 0, "Unbalanced %s() on %s:%s!\n", __func__, + clk->dev_id, clk->id)) + clk->enable++; + else if (!enable && clk->ops->disable) + clk->ops->disable(clk); + mutex_unlock(&clk->lock); +} +EXPORT_SYMBOL(v4l2_clk_disable); + +unsigned long v4l2_clk_get_rate(struct v4l2_clk *clk) +{ + if (!clk->ops->get_rate) + return -ENOSYS; + + return clk->ops->get_rate(clk); +} +EXPORT_SYMBOL(v4l2_clk_get_rate); + +int v4l2_clk_set_rate(struct v4l2_clk *clk, unsigned long rate) +{ + if (!clk->ops->set_rate) + return -ENOSYS; + + return clk->ops->set_rate(clk, rate); +} +EXPORT_SYMBOL(v4l2_clk_set_rate); + +struct v4l2_clk *v4l2_clk_register(const struct v4l2_clk_ops *ops, + const char *dev_id, + const char *id, void *priv) +{ + struct v4l2_clk *clk; + int ret; + + if (!ops || !dev_id) + return ERR_PTR(-EINVAL); + + clk = kzalloc(sizeof(struct v4l2_clk), GFP_KERNEL); + if (!clk) + return ERR_PTR(-ENOMEM); + + clk->id = kstrdup(id, GFP_KERNEL); + clk->dev_id = kstrdup(dev_id, GFP_KERNEL); + if ((id && !clk->id) || !clk->dev_id) { + ret = -ENOMEM; + goto ealloc; + } + clk->ops = ops; + clk->priv = priv; + atomic_set(&clk->use_count, 0); + mutex_init(&clk->lock); + + mutex_lock(&clk_lock); + if (!IS_ERR(v4l2_clk_find(dev_id, id))) { + mutex_unlock(&clk_lock); + ret = -EEXIST; + goto eexist; + } + list_add_tail(&clk->list, &clk_list); + mutex_unlock(&clk_lock); + + return clk; + +eexist: +ealloc: + kfree(clk->id); + kfree(clk->dev_id); + kfree(clk); + return ERR_PTR(ret); +} +EXPORT_SYMBOL(v4l2_clk_register); + +void v4l2_clk_unregister(struct v4l2_clk *clk) +{ + if (unlikely(atomic_read(&clk->use_count))) { + pr_err("%s(): Unregistering ref-counted %s:%s clock!\n", + __func__, clk->dev_id, clk->id); + BUG(); + } + + mutex_lock(&clk_lock); + list_del(&clk->list); + mutex_unlock(&clk_lock); + + kfree(clk->id); + kfree(clk->dev_id); + kfree(clk); +} +EXPORT_SYMBOL(v4l2_clk_unregister); diff --git a/include/media/v4l2-clk.h b/include/media/v4l2-clk.h new file mode 100644 index 0000000..9b67472 --- /dev/null +++ b/include/media/v4l2-clk.h @@ -0,0 +1,54 @@ +/* + * V4L2 clock service + * + * Copyright (C) 2012, Guennadi Liakhovetski + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * ATTENTION: This is a temporary API and it shall be replaced by the generic + * clock API, when the latter becomes widely available. + */ + +#ifndef MEDIA_V4L2_CLK_H +#define MEDIA_V4L2_CLK_H + +#include +#include +#include + +struct module; +struct v4l2_subdev; + +struct v4l2_clk { + struct list_head list; + const struct v4l2_clk_ops *ops; + const char *dev_id; + const char *id; + int enable; + struct mutex lock; /* Protect the enable count */ + atomic_t use_count; + void *priv; +}; + +struct v4l2_clk_ops { + struct module *owner; + int (*enable)(struct v4l2_clk *clk); + void (*disable)(struct v4l2_clk *clk); + unsigned long (*get_rate)(struct v4l2_clk *clk); + int (*set_rate)(struct v4l2_clk *clk, unsigned long); +}; + +struct v4l2_clk *v4l2_clk_register(const struct v4l2_clk_ops *ops, + const char *dev_name, + const char *name, void *priv); +void v4l2_clk_unregister(struct v4l2_clk *clk); +struct v4l2_clk *v4l2_clk_get(struct v4l2_subdev *sd, const char *id); +void v4l2_clk_put(struct v4l2_clk *clk); +int v4l2_clk_enable(struct v4l2_clk *clk); +void v4l2_clk_disable(struct v4l2_clk *clk); +unsigned long v4l2_clk_get_rate(struct v4l2_clk *clk); +int v4l2_clk_set_rate(struct v4l2_clk *clk, unsigned long rate); + +#endif