Hi Kai, Sam.
I have a single file foo.c that I want to generate two (ALSA) modules from,
snd-foo2000.ko and snd-foo2001.ko, by compiling with either FOO2000 or
FOO2001 defined.
I can do this, and ALSA does this a few times, by providing dummy foo2000.c
and foo2001.c files, like:
=== foo2000.c
#define FOO2000
#include "foo.c"
===
and a regular Makefile
===
foo2000-objs := foo2000.o
foo2001-objs := foo2001.o
obj-$(CONFIG_SND_FOO2000) += snd-foo2000.o
obj-$(CONFIG_SND_F002001) += snd-foo2001.o
===
That #include is a little lame though. Is there a nicer way? I noticed the
per-file CFLAGS, but given that it's one source file for both, that doesn't fit.
Rene.
Rene Herman wrote:
> Hi Kai, Sam.
>
> I have a single file foo.c that I want to generate two (ALSA) modules
> from, snd-foo2000.ko and snd-foo2001.ko, by compiling with either
> FOO2000 or FOO2001 defined.
>
> I can do this, and ALSA does this a few times, by providing dummy
> foo2000.c and foo2001.c files, like:
>
> === foo2000.c
> #define FOO2000
> #include "foo.c"
> ===
>
> and a regular Makefile
>
> ===
> foo2000-objs := foo2000.o
> foo2001-objs := foo2001.o
>
> obj-$(CONFIG_SND_FOO2000) += snd-foo2000.o
> obj-$(CONFIG_SND_F002001) += snd-foo2001.o
> ===
>
> That #include is a little lame though. Is there a nicer way? I noticed
> the per-file CFLAGS, but given that it's one source file for both, that
> doesn't fit.
>
The stub source file is usually considered a good way to do this.
-hpa
On 09/15/2007 01:13 AM, H. Peter Anvin wrote:
> Rene Herman wrote:
>> I have a single file foo.c that I want to generate two (ALSA) modules
>> from, snd-foo2000.ko and snd-foo2001.ko, by compiling with either
>> FOO2000 or FOO2001 defined.
>>
>> I can do this, and ALSA does this a few times, by providing dummy
>> foo2000.c and foo2001.c files, like:
>>
>> === foo2000.c
>> #define FOO2000
>> #include "foo.c"
>> ===
>>
>> and a regular Makefile
>>
>> ===
>> foo2000-objs := foo2000.o
>> foo2001-objs := foo2001.o
>>
>> obj-$(CONFIG_SND_FOO2000) += snd-foo2000.o
>> obj-$(CONFIG_SND_F002001) += snd-foo2001.o
>> ===
>>
>> That #include is a little lame though. Is there a nicer way? I noticed
>> the per-file CFLAGS, but given that it's one source file for both, that
>> doesn't fit.
>>
>
> The stub source file is usually considered a good way to do this.
Mmm. If I'll have to live with it, I can, but thought I'd ask if there was
some nice build trickery available instead.
Rene.
On Sat, Sep 15, 2007 at 01:30:21AM +0200, Rene Herman wrote:
> On 09/15/2007 01:13 AM, H. Peter Anvin wrote:
>
>> Rene Herman wrote:
>
>>> I have a single file foo.c that I want to generate two (ALSA) modules
>>> from, snd-foo2000.ko and snd-foo2001.ko, by compiling with either
>>> FOO2000 or FOO2001 defined.
>>>
>>> I can do this, and ALSA does this a few times, by providing dummy
>>> foo2000.c and foo2001.c files, like:
>>>
>>> === foo2000.c
>>> #define FOO2000
>>> #include "foo.c"
>>> ===
>>>
>>> and a regular Makefile
>>>
>>> ===
>>> foo2000-objs := foo2000.o
>>> foo2001-objs := foo2001.o
>>>
>>> obj-$(CONFIG_SND_FOO2000) += snd-foo2000.o
>>> obj-$(CONFIG_SND_F002001) += snd-foo2001.o
>>> ===
>>>
>>> That #include is a little lame though. Is there a nicer way? I noticed
>>> the per-file CFLAGS, but given that it's one source file for both, that
>>> doesn't fit.
>>>
>> The stub source file is usually considered a good way to do this.
>
> Mmm. If I'll have to live with it, I can, but thought I'd ask if there was
> some nice build trickery available instead.
The usual trick is to create _three_ modules:
Two with the foo2000 and foo2001 specific parts, and a third one with
all code used by both.
Or if foo2000 and foo2001 differ only in small details, create one
snd-foo200x module supporting both at the same time.
> Rene.
cu
Adrian
--
"Is there not promise of rain?" Ling Tan asked suddenly out
of the darkness. There had been need of rain for many days.
"Only a promise," Lao Er said.
Pearl S. Buck - Dragon Seed
On 09/15/2007 10:47 AM, Adrian Bunk wrote:
> On Sat, Sep 15, 2007 at 01:30:21AM +0200, Rene Herman wrote:
>> On 09/15/2007 01:13 AM, H. Peter Anvin wrote:
>>
>>> Rene Herman wrote:
>>>> I have a single file foo.c that I want to generate two (ALSA) modules
>>>> from, snd-foo2000.ko and snd-foo2001.ko, by compiling with either
>>>> FOO2000 or FOO2001 defined.
>>>>
>>>> I can do this, and ALSA does this a few times, by providing dummy
>>>> foo2000.c and foo2001.c files, like:
>>>>
>>>> === foo2000.c
>>>> #define FOO2000
>>>> #include "foo.c"
>>>> ===
[ ... ]
>>> The stub source file is usually considered a good way to do this.
>> Mmm. If I'll have to live with it, I can, but thought I'd ask if there was
>> some nice build trickery available instead.
>
> The usual trick is to create _three_ modules:
>
> Two with the foo2000 and foo2001 specific parts, and a third one with
> all code used by both.
>
> Or if foo2000 and foo2001 differ only in small details, create one
> snd-foo200x module supporting both at the same time.
Thanks for the comment. Yes, first would be massive overkill in this case
and second somewhat annoying as one of the differences is support for
different resources (IRQs) among the two versions, whereas I'm checking the
validity of the passed in values at a time I do not know which version I'm
looking at yet -- knowing that requires having talked to the hardware.
Can do, but for now it seems like the two seperate modules might be cleaner.
Can keep things much more straighforward that way by just redefining a bunch
of #defines.
I'll just do the split version first and if someone really wants me to, I'll
merge them after all...
Rene
On Sat, Sep 15, 2007 at 05:17:08PM +0200, Rene Herman wrote:
> On 09/15/2007 10:47 AM, Adrian Bunk wrote:
>
>> On Sat, Sep 15, 2007 at 01:30:21AM +0200, Rene Herman wrote:
>>> On 09/15/2007 01:13 AM, H. Peter Anvin wrote:
>>>
>>>> Rene Herman wrote:
>>>>> I have a single file foo.c that I want to generate two (ALSA) modules
>>>>> from, snd-foo2000.ko and snd-foo2001.ko, by compiling with either
>>>>> FOO2000 or FOO2001 defined.
>>>>>
>>>>> I can do this, and ALSA does this a few times, by providing dummy
>>>>> foo2000.c and foo2001.c files, like:
>>>>>
>>>>> === foo2000.c
>>>>> #define FOO2000
>>>>> #include "foo.c"
>>>>> ===
>
> [ ... ]
>
>>>> The stub source file is usually considered a good way to do this.
>>> Mmm. If I'll have to live with it, I can, but thought I'd ask if there
>>> was some nice build trickery available instead.
>> The usual trick is to create _three_ modules:
>> Two with the foo2000 and foo2001 specific parts, and a third one with all
>> code used by both.
>> Or if foo2000 and foo2001 differ only in small details, create one
>> snd-foo200x module supporting both at the same time.
>
> Thanks for the comment. Yes, first would be massive overkill in this case
> and second somewhat annoying as one of the differences is support for
> different resources (IRQs) among the two versions, whereas I'm checking the
> validity of the passed in values at a time I do not know which version I'm
> looking at yet -- knowing that requires having talked to the hardware.
I'm not getting this point.
Consider both snd-foo2000 and snd-foo2001 are compiled statically into
the kernel - somehow one of them must realize quite early that it's not
responsible for the device.
And however this is done, it should similarly work in one module
supporting both.
> Can do, but for now it seems like the two seperate modules might be
> cleaner. Can keep things much more straighforward that way by just
> redefining a bunch of #defines.
>
> I'll just do the split version first and if someone really wants me to,
> I'll merge them after all...
>
> Rene
cu
Adrian
--
"Is there not promise of rain?" Ling Tan asked suddenly out
of the darkness. There had been need of rain for many days.
"Only a promise," Lao Er said.
Pearl S. Buck - Dragon Seed
On Saturday 15 September 2007 16:17, Rene Herman wrote:
> On 09/15/2007 10:47 AM, Adrian Bunk wrote:
> >>> The stub source file is usually considered a good way to do this.
> >> Mmm. If I'll have to live with it, I can, but thought I'd ask if there was
> >> some nice build trickery available instead.
> >
> > The usual trick is to create _three_ modules:
> >
> > Two with the foo2000 and foo2001 specific parts, and a third one with
> > all code used by both.
> >
> > Or if foo2000 and foo2001 differ only in small details, create one
> > snd-foo200x module supporting both at the same time.
>
> Thanks for the comment. Yes, first would be massive overkill in this case
> and second somewhat annoying as one of the differences is support for
> different resources (IRQs) among the two versions, whereas I'm checking the
> validity of the passed in values at a time I do not know which version I'm
> looking at yet -- knowing that requires having talked to the hardware.
If I understood you right, this is PCI, USB or other kind of devices
where module is selected according to PCI/USB/whatever IDs.
You thinking is - if module foo2000 is loaded, this is definitely a
2000 device and you can "check the validity of the passed in values"
for the device 2000 now.
Correct me if I'm wrong.
But you can do absolutely the same at runtime in unified driver,
since PCI/USB/whatever IDs are accessible to the driver.
Two drivers will most likely have code duplication.
Unified driver will be harder to read and maintain because of all
ifs/switch's/function pointers you need.
The choice depends on *how much* maintainability pain you can
tolerate by taking "unified code" path.
> Can do, but for now it seems like the two seperate modules might be cleaner.
Can you give a bit more info what the dirrefences between devices are
in this particular cases?
--
vda
On 09/15/2007 05:53 PM, Denys Vlasenko wrote:
> Can you give a bit more info what the dirrefences between devices are
> in this particular cases?
It's ISA. Thanks, but never mind guys, I only wanted to know something about
kbuild.
Rene.