Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S932307Ab3CPCZg (ORCPT ); Fri, 15 Mar 2013 22:25:36 -0400 Received: from hqemgate04.nvidia.com ([216.228.121.35]:14481 "EHLO hqemgate04.nvidia.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1755511Ab3CPCZe (ORCPT ); Fri, 15 Mar 2013 22:25:34 -0400 X-PGP-Universal: processed; by hqnvupgp07.nvidia.com on Fri, 15 Mar 2013 19:25:27 -0700 Message-ID: <1363400755.3875.0.camel@bilhuang-vm1> Subject: Re: [RFC 1/1] clk: Add notifier support in clk_prepare_enable/clk_disable_unprepare From: Bill Huang To: Russell King - ARM Linux CC: Stephen Warren , "mturquette@linaro.org" , "linux-kernel@vger.kernel.org" , "linaro-dev@lists.linaro.org" , "linux-arm-kernel@lists.infradead.org" , "patches@linaro.org" Date: Fri, 15 Mar 2013 19:25:55 -0700 In-Reply-To: <20130315170945.GM4977@n2100.arm.linux.org.uk> References: <1363091861-21534-1-git-send-email-bilhuang@nvidia.com> <20130312134032.GU4977@n2100.arm.linux.org.uk> <1363139273.21694.11.camel@bilhuang-vm1> <514003B6.8020904@wwwdotorg.org> <1363151317.3311.9.camel@bilhuang-vm1> <51400D9D.9060305@wwwdotorg.org> <1363153204.3311.14.camel@bilhuang-vm1> <20130315170945.GM4977@n2100.arm.linux.org.uk> X-Mailer: Evolution 3.2.3-0ubuntu6 MIME-Version: 1.0 Content-Type: text/plain; charset="ISO-8859-9" Content-Transfer-Encoding: 7bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Length: 3164 Lines: 66 On Sat, 2013-03-16 at 01:09 +0800, Russell King - ARM Linux wrote: > On Tue, Mar 12, 2013 at 10:40:04PM -0700, Bill Huang wrote: > > That will be too bad, it looks like we deadlock in the mechanism, we > > cannot change existing drivers behavior (that means some call > > clk_disable/enable directly, some are not), and we cannot hook notifier > > in clk_disable/enable either, that means there seems no any chance to > > get what we want, any idea? > > Look, the whole point is: > > - Drivers can call clk_enable/clk_disable from their atomic regions to > control the clock. Drivers which do this also call clk_prepare/ > clk_unprepare from a schedulable context to perform any operations > necessary to allow the clock to be used. > > - Drivers which only ever control the clock from a schedulable context > *can* use clk_prepare_enable()/clk_disable_unprepare() to control > their clock, which simplifies the coding in the driver. > > The whole point here is to cater for what is found on different SoCs and > not need to keep rewriting the drivers between different SoCs. > > So, the idea is that: > > - clk_prepare() does whatever is needed to prepare a clock for use which > may require waiting for the clock to be in a state which it can be > enabled. In other words, if there is a PLL, the PLL is setup and > we wait for it to report that it has locked. > > - clk_enable() is about turning the clock output on so that the device > receives the clock. > > Now, in the case of a PLL directly feeding a device, it's entirely possible > that clk_prepare() ends up providing the clock signal to the device, and > clk_enable() does absolutely nothing. > > Or, if the clock has a gate on it, it's entirely possible that clk_prepare() > does nothing, and clk_enable() unmasks the gate to allow the clock to be > provided to the device - which can happen from atomic contexts. > > The whole point about the separation of these two functions is that device > driver writers _can_ code their drivers for both situations and not care > about how the SoC implements the clocking at all. > > Why did we end up with this split in the first place? Because we ran into > the problem that some SoCs required a sleeping clk_enable() and others > didn't, and the whole thing was turning into an incompatible mess. > > So, please. Realise that clk_prepare() and clk_enable() are the _official_ > APIs, and that clk_prepare_enable() is merely a helper function for drivers > to allow them to automate the calling of those two functions in succession > with _no_ _further_ _processing_ at all. > > So, if your hooks need to be callable from schedulable contexts, then you > need to put them inside clk_prepare(). If your hooks are callable from > atomic contexts, then they can go into clk_enable(). But what you can > not do is put them into clk_prepare_enable(). Thanks a lot for good point. -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/