lkml.org 
[lkml]   [2012]   [May]   [2]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
/
Date
From
SubjectRe: [PATCH] clk: Use a separate struct for holding init data.
On 05/01/2012 07:04 PM, Mike Turquette wrote:
> On 20120425-22:58, Saravana Kannan wrote:
>> Create a struct clk_init_data to hold all data that needs to be passed from
>> the platfrom specific driver to the common clock framework during clock
>> registration. Add a pointer to this struct inside clk_hw.
>>
>> This has several advantages:
>> * Completely hides struct clk from many clock platform drivers and static
>> clock initialization code that don't care for static initialization of
>> the struct clks.
>> * For platforms that want to do complete static initialization, it removed
>> the need to directly mess with the struct clk's fields while still
>> allowing to statically allocate struct clk. This keeps the code more
>> future proof even if they include clk-private.h.
>> * Simplifies the generic clk_register() function and allows adding optional
>> fields in the future without modifying the function signature.
>> * Simplifies the static initialization of clocks on all platforms by
>> removing the need for forward delcarations or convoluted macros.
>>
>> Signed-off-by: Saravana Kannan<skannan@codeaurora.org>
>
> Hi Saravana,
>
> Thanks for the patch. I've taken it into my clk-next but I have two
> points:

Yayyy!! Finally I can get rid of having to know about struct clk.

> 1) I'm surprised that you abandoned the approach of exposing the
> less-private members of struct clk via struct clk_hw. Your original
> patch did just that, but did not account for static initialization.
> This patch seems to have gone in the opposite direction and only
> accounts for static initialization.

I think there might be some misunderstanding on what can/can't be done
with my patch. Or may be I'm not understanding your question.

I used to expose the "shared" info through clk_hw. I just put them in a
struct and make clk_hw point to it. This would allow for easily marking
this shared info as __init data. It would have a been a pain to do (or
not even possible) if I had put the fields directly into clk_hw.

I'm not sure why you say my patch only accounts for static
initialization. The entire clk specific struct (say, struct fixed_clk),
the clk_init_data can be dynamically allocated and registered using
clk_register.

For completely static init, you can just do:

#include <linux/clk-private.h>

static struct clk __my_clk;

static struct clk_init_data __my_clki = {
<fill in shared fields>
};

static struct fixed_clk my_clk = {
.blah = 10,
.hw = {
.i = &__my_clki;
.c = &__my_clk;
},
};

__clk_register(&my_clk.hw);

>
> I'm happy to take the patch as-is, but I did think that there were
> merits to your original approach.

Is there anything the first patch could do that this one couldn't?

The only small demerit of this patch that I know is that we could be
doing some copying of the shared data when we do clk_register() (this
prevents us from having one copy of parent list, etc).

>
> 2) I did make a modification to your patch where I kept the
> DEFINE_CLK_* macros and continued to declare __clk_init in
> clk-private.h. I do want to get rid of both of these in the future but
> currently my platform relies on static initialization before the
> allocator is available. Please let me know if this causes a problem for
> you.

I definitely had your requirements in mind too when I made the changes.

You really shouldn't need __clk_init. That's why I added __clk_register.
With __clk_register (and the example I gave above), you should be able
to do fully static init. Is there something I missed?

The DEFINE_CLK_* marcos aren't really very useful since there is no
cyclic referencing going on.

You also don't really need to define variables for struct clk or struct
clk_init_data. You can create anonymous struct pointers if that's your
style. Something like:


static struct fixed_clk my_clk = {
.blah = 10,
.hw = {
.i = &(struct clk_init_data) {
<fill in shared fields>
},
.c = &(struct clk){};
},
};

So, with one of the above approaches, DEFINE_CLK_* macros just end up
obfuscating the definition of a clock and its fields.

With __clk_register() the only real difference between fully static and
partly dynamic clock registration is that you don't mark the
clk_init_data struct as __init and you call __clk_register() instead of
clk_register(). I believe I documented it next to __clk_register() in clk.c.

> Platform folks should rebase on top of this if needed. This should be
> the last change to the driver/platform-facing API before 3.5.

I really wish we discussed your changes before it was made, pulled in
and announced since clk_init isn't really needed. But since you just
added more APIs and didn't remove the ones I added, I guess it's not
very bad.

Since people were already frustrated with the API change I made at this
point, can we recommend people to not use __clk_init() when sending
patches for your clk-next? And make it static after the next kernel release?

Thanks,
Saravana

--
Sent by an employee of the Qualcomm Innovation Center, Inc.
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum.


\
 
 \ /
  Last update: 2012-05-02 07:21    [W:0.318 / U:0.456 seconds]
©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site