Request for Clarification: old - legacy - new driver model

Request for Clarification: old - legacy - new driver model

[Michael Lawnick]

Hi all,

postings like the one by Ben Dooks, on 15 Jul 2008 15:58:21 GMT
<20080715155144.136915800-elnMNo+KYs3pIgCt6eIbzw@public.gmane.org> talk about 'old style', 'legacy
driver' and 'new driver model'

Having had MUXes and a 2.4 kernel in the past, we currently use a 2.6.26
kernel on a board with no MUX, but will have multiple MUXes, probably
cascaded, on next generation of our project.
Currently I'm trying to find out what is 'state of the art' and have
problems  to connect 'old' (='legacy'?) and 'new' to a specific kernel
version.
What is the major difference between 'new' and 'legacy' model?

Can someone give me explanations/links/msg ids?

-- 
TIA

Michael

Re: Request for Clarification: old - legacy - new driver model

[Wolfram Sang]

[-- Attachment #1: Type: text/plain, Size: 290 bytes --]

Hi Michael,

> Can someone give me explanations/links/msg ids?

Documentation/i2c/upgrading-clients

Regards,

   Wolfram

-- 
Pengutronix e.K.                           | Wolfram Sang                |
Industrial Linux Solutions                 | http://www.pengutronix.de/  |

[-- Attachment #2: Digital signature --]
[-- Type: application/pgp-signature, Size: 197 bytes --]

Re: Request for Clarification: old - legacy - new driver model

[Michael Lawnick]

Wolfram Sang said the following:
> Hi Michael,
> 
>> Can someone give me explanations/links/msg ids?
> 
> Documentation/i2c/upgrading-clients
> 
After re-reading it, I have to state that this document doesn't answer
the questions behind my original ones (which I wanted to answer myself
by following helpful links):
>From which kernel version on should the 'new-binding' model work?
How is attaching of a hot plugged i2c device achieved a) from kernel b)
from user space.
For kernel space init I assume its a call to i2c_new_device(). Here I'm
wondering where I should get the adapter info from.
For user space I'm completely lost (ioctl on /dev/i2cx?).

Our situation: main board is up and running, all drivers loaded.
Now an extension board will be plugged in. It is detected by
periodically polling via I2C for MUX. After detection the drivers e.g.
for temperature an MUX on the secondary board need to be attached to I2C
subsystem. Instances of both drivers are already running for local
devices, re-loading is only a bad option.
Do I really have to read and understand i2c-core.c and i2c-dev.c to find
out?
-- 

Michael Lawnick
Software Design Engineer

Lise-Meitner-Str. 7/1
89081 Ulm
Tel: +49 731 9533 2066

Michael.Lawnick.ext-OYasijW0DpE@public.gmane.org
http://www.nokiasiemensnetworks.com/global/

Think before you print

Re: Request for Clarification: old - legacy - new driver model

[Jean Delvare]

On Thu, 19 Feb 2009 15:17:13 +0100, Michael Lawnick wrote:
> Wolfram Sang said the following:
> > Hi Michael,
> > 
> >> Can someone give me explanations/links/msg ids?
> > 
> > Documentation/i2c/upgrading-clients
> > 
> After re-reading it, I have to state that this document doesn't answer
> the questions behind my original ones (which I wanted to answer myself
> by following helpful links):
> From which kernel version on should the 'new-binding' model work?

It started in kernel 2.6.22. But there were significant changes later
in kernels 2.6.25 and 2.6.26.

> How is attaching of a hot plugged i2c device achieved a) from kernel b)
> from user space.

The I2C bus doesn't support hot-plugging, so I am not sure what you
mean?

> For kernel space init I assume its a call to i2c_new_device(). Here I'm
> wondering where I should get the adapter info from.

Depends. i2c_new_device() is suitable for TV adapters for example. For
embedded boards, you'd rather declare all I2C devices with
i2c_register_board_info() and use fixed I2C bus numbers.

> For user space I'm completely lost (ioctl on /dev/i2cx?).

User-space access through i2c-dev is entirely unchanged.

If you mean creating I2C devices from user-space, the interface for
this doesn't exist yet. I have a simple one in mind, but I can never
find the time to work on it :/

That being said, this can be worked around using the old
I2C_CLIENT_INSMOD macros. These let you pass module parameters forcing
clients at a specific address.

> Our situation: main board is up and running, all drivers loaded.
> Now an extension board will be plugged in. It is detected by
> periodically polling via I2C for MUX. After detection the drivers e.g.

This is totally unsupported. I2C isn't an hot-pluggable bus.

(Not to mention that support for mux chips is currently missing, but at
least this is being worked on and fixable.)

> for temperature an MUX on the secondary board need to be attached to I2C
> subsystem. Instances of both drivers are already running for local
> devices, re-loading is only a bad option.

You shouldn't have to reload any driver.

> Do I really have to read and understand i2c-core.c and i2c-dev.c to find
> out?

i2c-dev most probably doesn't have anything to do with your problem.

What you are missing, as far as I can see, is proper mux support.
Rodolfo Giometti (Cc'd) is working on this, if you want to test his
patches (which I still didn't have the time to look at, sadly.)

-- 
Jean Delvare

Re: Request for Clarification: old - legacy - new driver model

[Michael Lawnick]

Jean Delvare said the following:
> On Thu, 19 Feb 2009 15:17:13 +0100, Michael Lawnick wrote:
<snip>
>> Our situation: main board is up and running, all drivers loaded.
>> Now an extension board will be plugged in. It is detected by
>> periodically polling via I2C for MUX. After detection the drivers e.g.
> 
> This is totally unsupported. I2C isn't an hot-pluggable bus.
> 
<snip>
> 
> What you are missing, as far as I can see, is proper mux support.
> Rodolfo Giometti (Cc'd) is working on this, if you want to test his
> patches (which I still didn't have the time to look at, sadly.)
> 
I have seen the patches, I am planning based on them.

Well, thinking about it, I hope to have a solution.
Here is what a H/W might look like:
                          +-------+   +--------+
                          |  LM75 |   | EEPROM |
                          +-------+   +--------+
 Mainboard                    |           |
+------------+                |           |
| controller |----------------+-----+-----+---....
+------------+                      |
                                    |
                                    |
                                 +------+
                                 |      |
   ...>--------------------------| MUX1 |----------------------<...
               +-----------------|      |---------------+
               |                 +------+               |
               |                                        |
               |                                        |
               ^                                        ^
Plugin1        |                          Plugin2       |
            +------+                                +------+
            |      |   +-------+                    |      |   +-------+
        +---| MUX2 |---|  LM75 |                +---| MUX3 |---|  LM75 |
        |   |      |   +-------+                |   |      |   +-------+
        |   +------+                            |   +------+
        |                                       |
        |   +-------+                           |   +-------+
        +---|  LM75 |                           +---|  LM75 |
        |   +-------+                           |   +-------+
        |                                       |
        |   +--------+                          |   +--------+
        +---| EEPROM |                          +---| EEPROM |
        |   +--------+                          |   +--------+
        |                                       |


The idea: when deferring the instantiation of the adapters of MUX1,
there should be something like a hot-plug event.
AFAIK, after adding an adapter via i2c_add_numbered_adapter(), the I2C
subsystem will probe for all currently known clients on this new bus.
Correct?
If so, this should cascade through the newly plugged in board.

This defer could be implemented by removing auto instantiation (module
parameter) but adding a sysFs entry on MUX that does it on demand:
#start controller 5
echo 5 > /sys/bus/i2c/devices/1-0020/startAdapter
#stop controller 5
echo 5 > /sys/bus/i2c/devices/1-0020/stopAdapter

Any contradictions?

-- 
Regards,
Michael

Re: Request for Clarification: old - legacy - new driver model

[Jean Delvare]

Hi Michael,

On Tue, 24 Feb 2009 16:09:33 +0100, Michael Lawnick wrote:
> Jean Delvare said the following:
> > On Thu, 19 Feb 2009 15:17:13 +0100, Michael Lawnick wrote:
> <snip>
> >> Our situation: main board is up and running, all drivers loaded.
> >> Now an extension board will be plugged in. It is detected by
> >> periodically polling via I2C for MUX. After detection the drivers e.g.
> > 
> > This is totally unsupported. I2C isn't an hot-pluggable bus.
> > 
> <snip>
> > 
> > What you are missing, as far as I can see, is proper mux support.
> > Rodolfo Giometti (Cc'd) is working on this, if you want to test his
> > patches (which I still didn't have the time to look at, sadly.)
> > 
> I have seen the patches, I am planning based on them.
> 
> Well, thinking about it, I hope to have a solution.
> Here is what a H/W might look like:
>                           +-------+   +--------+
>                           |  LM75 |   | EEPROM |
>                           +-------+   +--------+
>  Mainboard                    |           |
> +------------+                |           |
> | controller |----------------+-----+-----+---....
> +------------+                      |
>                                     |
>                                     |
>                                  +------+
>                                  |      |
>    ...>--------------------------| MUX1 |----------------------<...
>                +-----------------|      |---------------+
>                |                 +------+               |
>                |                                        |
>                |                                        |
>                ^                                        ^
> Plugin1        |                          Plugin2       |
>             +------+                                +------+
>             |      |   +-------+                    |      |   +-------+
>         +---| MUX2 |---|  LM75 |                +---| MUX3 |---|  LM75 |
>         |   |      |   +-------+                |   |      |   +-------+
>         |   +------+                            |   +------+
>         |                                       |
>         |   +-------+                           |   +-------+
>         +---|  LM75 |                           +---|  LM75 |
>         |   +-------+                           |   +-------+
>         |                                       |
>         |   +--------+                          |   +--------+
>         +---| EEPROM |                          +---| EEPROM |
>         |   +--------+                          |   +--------+
>         |                                       |
> 

I don't quite get the point of MUX2 and MUX3.

> 
> The idea: when deferring the instantiation of the adapters of MUX1,
> there should be something like a hot-plug event.
> AFAIK, after adding an adapter via i2c_add_numbered_adapter(), the I2C
> subsystem will probe for all currently known clients on this new bus.
> Correct?
> If so, this should cascade through the newly plugged in board.

For I2C chip drivers which do device autodetection (lm75 and eeprom are
amongst them but for example at24 is not) yes. For other drivers (say
at24) there should be a board definition for the new i2c bus segment.
This might be a little difficult to implement with the traditional
i2c_register_board_info() due to the hotplug nature is not all plugins
have the same set of I2C chips. But some custom code using
i2c_new_device() should do.

> This defer could be implemented by removing auto instantiation (module
> parameter)

Auto instantiation only happens if the bus driver asks for it (through
an I2C_CLASS_* flag). If you don't want it, no need for a module
parameter, simply don't set any class flag.

> but adding a sysFs entry on MUX that does it on demand:
> #start controller 5
> echo 5 > /sys/bus/i2c/devices/1-0020/startAdapter
> #stop controller 5
> echo 5 > /sys/bus/i2c/devices/1-0020/stopAdapter
> 
> Any contradictions?

What are you trying to achieve? What is wrong with auto instantiation
as it is implemented today?

-- 
Jean Delvare

Re: Request for Clarification: old - legacy - new driver model

[Michael Lawnick]

Jean Delvare said the following:
> Hi Michael,
> 
> On Tue, 24 Feb 2009 16:09:33 +0100, Michael Lawnick wrote:
>> Jean Delvare said the following:
>> > On Thu, 19 Feb 2009 15:17:13 +0100, Michael Lawnick wrote:
>> <snip>
>> >> Our situation: main board is up and running, all drivers loaded.
>> >> Now an extension board will be plugged in. It is detected by
>> >> periodically polling via I2C for MUX. After detection the drivers e.g.
>> > 
>> > This is totally unsupported. I2C isn't an hot-pluggable bus.
>> > 
>> <snip>
>> > 
>> > What you are missing, as far as I can see, is proper mux support.
>> > Rodolfo Giometti (Cc'd) is working on this, if you want to test his
>> > patches (which I still didn't have the time to look at, sadly.)
>> > 
>> I have seen the patches, I am planning based on them.
>> 
>> Well, thinking about it, I hope to have a solution.
>> Here is what a H/W might look like:
>>                           +-------+   +--------+
>>                           |  LM75 |   | EEPROM |
>>                           +-------+   +--------+
>>  Mainboard                    |           |
>> +------------+                |           |
>> | controller |----------------+-----+-----+---....
>> +------------+                      |
>>                                     |
>>                                     |
>>                                  +------+
>>                                  |      |
>>    ...>--------------------------| MUX1 |----------------------<...
>>                +-----------------|      |---------------+
>>                |                 +------+               |
>>                |                                        |
>>                |                                        |
>>                ^                                        ^
>> Plugin1        |                          Plugin2       |
>>             +------+                                +------+
>>             |      |   +-------+                    |      |   +-------+
>>         +---| MUX2 |---|  LM75 |                +---| MUX3 |---|  LM75 |
>>         |   |      |   +-------+                |   |      |   +-------+
>>         |   +------+                            |   +------+
>>         |                                       |
>>         |   +-------+                           |   +-------+
>>         +---|  LM75 |                           +---|  LM75 |
>>         |   +-------+                           |   +-------+
>>         |                                       |
>>         |   +--------+                          |   +--------+
>>         +---| EEPROM |                          +---| EEPROM |
>>         |   +--------+                          |   +--------+
>>         |                                       |
>> 
> 
> I don't quite get the point of MUX2 and MUX3.

Only 2 LM75 per MUX are shown above, but there will be 10+ in real ...
Don't ask - H/W engineers ...

> 
>> 
>> The idea: when deferring the instantiation of the adapters of MUX1,
>> there should be something like a hot-plug event.
>> AFAIK, after adding an adapter via i2c_add_numbered_adapter(), the I2C
>> subsystem will probe for all currently known clients on this new bus.
>> Correct?
>> If so, this should cascade through the newly plugged in board.
> 
> For I2C chip drivers which do device autodetection (lm75 and eeprom are
> amongst them but for example at24 is not) yes. For other drivers (say
> at24) there should be a board definition for the new i2c bus segment.

I don't get the point here. The problem of correct identification will
have to be solved in any case.

> This might be a little difficult to implement with the traditional
> i2c_register_board_info() due to the hotplug nature is not all plugins
> have the same set of I2C chips. But some custom code using
> i2c_new_device() should do.

This would have to be done in kernel, doesn't it? I dislike such an
idea. Furthermore I raise the question of my previous posting again:
>>> For kernel space init I assume its a call to i2c_new_device(). Here I'm
>>> wondering where I should get the adapter info from.

> 
>> This defer could be implemented by removing auto instantiation (module
>> parameter)
> 
> Auto instantiation only happens if the bus driver asks for it (through
> an I2C_CLASS_* flag). If you don't want it, no need for a module
> parameter, simply don't set any class flag.
> 
What was meant is the auto instantiation of sub controllers.
I'm talking based on i2c-pca954x.c posted by Rodolfo Giometti on
01/28/09. I can't see an class attribute there. So how gets it
instantiated? Until now I assumed an automatic call of probe() for every
host controller.

>> but adding a sysFs entry on MUX that does it on demand:
>> #start controller 5
>> echo 5 > /sys/bus/i2c/devices/1-0020/startAdapter
>> #stop controller 5
>> echo 5 > /sys/bus/i2c/devices/1-0020/stopAdapter
>> 
>> Any contradictions?
> 
> What are you trying to achieve? 

Dynamically add of new instances of already running devices to the I2C
system.

> What is wrong with auto instantiation
> as it is implemented today?
> 
The point of time when it is done (AFAICS);-)
As I previously said:
>>>> Our situation: main board is up and running, all drivers loaded.
>>>> Now an extension board will be plugged in. It is detected by
>>>> periodically polling via I2C for MUX. After detection the drivers e.g.
>>>> for temperature an MUX on the secondary board need to be attached to I2C
>>>> subsystem. Instances of both drivers are already running for local
>>>> devices, re-loading is only a bad option.
Until now I can see no way to initiate an additional instantiation of an
I2C driver without reloading the module.

So far I have seen, the new model assumes a static network of devices
that can be initialized on boot strap. Information for this is taken
from device tree or kernel configuration data.
What I need is a user space initiated additional registration of a device.

I have the typical S/W engineers problem: no H/W, no documentation, but
should design and implement a system that has to run out of the box when
first version of H/W arrives ;-)
Therefore I asked for links in the OP so I can understand the idea of
the so called 'new I2C model'. The kernel documentation seems not to be
sufficient to achieve my goals.
Currently I'm waiting for 2 MUXes and an LM75, so I can connect them to
our current MUX-less board and start to play.

-- 

Michael Lawnick
Software Design Engineer

Lise-Meitner-Str. 7/1
89081 Ulm
Tel: +49 731 9533 2066

Michael.Lawnick.ext-OYasijW0DpE@public.gmane.org
http://www.nokiasiemensnetworks.com/global/

Think before you print

Re: Request for Clarification: old - legacy - new driver model

[Jean Delvare]

Hi Michael,

On Thu, 26 Feb 2009 12:09:52 +0100, Michael Lawnick wrote:
> Jean Delvare said the following:
> > On Tue, 24 Feb 2009 16:09:33 +0100, Michael Lawnick wrote:
> >> The idea: when deferring the instantiation of the adapters of MUX1,
> >> there should be something like a hot-plug event.
> >> AFAIK, after adding an adapter via i2c_add_numbered_adapter(), the I2C
> >> subsystem will probe for all currently known clients on this new bus.
> >> Correct?
> >> If so, this should cascade through the newly plugged in board.
> > 
> > For I2C chip drivers which do device autodetection (lm75 and eeprom are
> > amongst them but for example at24 is not) yes. For other drivers (say
> > at24) there should be a board definition for the new i2c bus segment.
> 
> I don't get the point here. The problem of correct identification will
> have to be solved in any case.

I have no idea what you mean here, sorry. Correct identification of
what?

> > This might be a little difficult to implement with the traditional
> > i2c_register_board_info() due to the hotplug nature is not all plugins
> > have the same set of I2C chips. But some custom code using
> > i2c_new_device() should do.
> 
> This would have to be done in kernel, doesn't it?

At the moment, yes. However, for some I2C drivers it is possible to
pass module parameters to force the instantiation of specific
i2c clients. This approach has shown its limits in the past (the most
problematic part being that the i2c adapter is identified by number,
while said number is usually not known in advance.)

> I dislike such an idea. 

I have been thinking about a way to instantiate (and destroy) i2c
clients from user-space. There are in fact two possible approaches. One
solely based on sysfs, where you would write the instantiation data to
a sysfs attribute file places in each i2c_adapter's directory. One
based on configfs. The former is much more simple and could be
implemented in a few hours, however it will not allow for fine-grained
device configuration. Anyway I didn't have the time to implement either
approach yet.

> Furthermore I raise the question of my previous posting again:
> For kernel space init I assume its a call to i2c_new_device(). Here I'm
> wondering where I should get the adapter info from.

I did answer this question already. But I can answer again.
i2c_new_device() is meant for I2C bus drivers which know what devices
are on the bus. The I2C bus driver does have a pointer to the
i2c_adapter, that it can pass to i2c_new_device().

Alternatively, if you know the I2C bus number, you can get a pointer to
the i2c_adapter in question using i2c_get_adapter(), and pass the
result to i2c_new_device(). Don't forget to call i2c_put_adapter() when
you're done.

> >> This defer could be implemented by removing auto instantiation (module
> >> parameter)
> > 
> > Auto instantiation only happens if the bus driver asks for it (through
> > an I2C_CLASS_* flag). If you don't want it, no need for a module
> > parameter, simply don't set any class flag.
>
> What was meant is the auto instantiation of sub controllers.

You presumably mean i2c bus segments.

> I'm talking based on i2c-pca954x.c posted by Rodolfo Giometti on
> 01/28/09. I can't see an class attribute there. So how gets it
> instantiated? Until now I assumed an automatic call of probe() for every
> host controller.

I didn't read Rodolfo's code yet (I would love to but I just can't find
the time, as I have many other ultra-urgent tasks accumulating since
the beginning of the month) but it I would expect the i2c-pca954x
driver to require platform data to determine the number of bus
segments, the mux combinations to read them, the class for each
segment, maybe the desired bus number for each segment, etc. I don't
think it is any realistic to expect a mux chip client to configure
itself automatically, especially when these mux chips can't be reliably
identified in the first place.

> > (...)
> > What is wrong with auto instantiation as it is implemented today?
>
> The point of time when it is done (AFAICS);-)

Yes, I agree this is a problem :( Currently I am fighting on the v4l
side to get rid of the legacy binding model. I don't see much point in
tackling other i2c-core issues before this is done, because the legacy
binding model gets in the way of about everything serious.

> (...)
> Until now I can see no way to initiate an additional instantiation of an
> I2C driver without reloading the module.

I think you really need to clear up you mind with the concepts of
device and driver. There is no such thing as an "instance of a driver".
When you load an I2C device driver module, there's (normally) only one
driver that is registered, regardless of the number of current or
future supported I2C devices in the system. I2C device instances (which
we tend to name "I2C clients" in the Linux kernel) can then come and go
at any point in time. Reloading the module has zero effect; it's
neither required nor even useful.

> So far I have seen, the new model assumes a static network of devices
> that can be initialized on boot strap. Information for this is taken
> from device tree or kernel configuration data.

This is one of the 3 ways the new model can work, yes.

> What I need is a user space initiated additional registration of a device.

While this could be implemented (see my short proposals above) I never
meant it to be used beyond debugging or temporary workaround.
Instantiating devices from user-space suggests that user-space knows
things about the hardware which the kernel itself doesn't know, this
doesn't sound exactly right.

> I have the typical S/W engineers problem: no H/W, no documentation, but
> should design and implement a system that has to run out of the box when
> first version of H/W arrives ;-)

And you have the additional typical problem that stubborn kernel
subsystem maintainers can't read your mind and magically figure out
what you need and implement it in the day.

> Therefore I asked for links in the OP so I can understand the idea of
> the so called 'new I2C model'. The kernel documentation seems not to be
> sufficient to achieve my goals.
> Currently I'm waiting for 2 MUXes and an LM75, so I can connect them to
> our current MUX-less board and start to play.

The documentation might not be perfect, right. It should become clearer
once we get completely rid of the legacy model. Contributions to
enhance the documentation are welcome, too.

-- 
Jean Delvare

Re: Request for Clarification: old - legacy - new driver model

[Michael Lawnick]

Jean Delvare said the following:
> Hi Michael,
> 
> On Thu, 26 Feb 2009 12:09:52 +0100, Michael Lawnick wrote:
>> Therefore I asked for links in the OP so I can understand the idea of
>> the so called 'new I2C model'. The kernel documentation seems not to be
>> sufficient to achieve my goals.
>> Currently I'm waiting for 2 MUXes and an LM75, so I can connect them to
>> our current MUX-less board and start to play.
> 
> The documentation might not be perfect, right. It should become clearer
> once we get completely rid of the legacy model. Contributions to
> enhance the documentation are welcome, too.
> 
Just in short:
Don't feel criticized here. The documentation feels excellent for making
new devices. But what I'm searching for are 'inner' documents, which
AFAICS LINUX lacks almost completely.

Kind Regards,
Michael

Re: Request for Clarification: old - legacy - new driver model

[Michael Lawnick]

Hi Jean,

Jean Delvare said the following:
> Hi Michael,
> 
> On Thu, 26 Feb 2009 12:09:52 +0100, Michael Lawnick wrote:
>> Jean Delvare said the following:
>> > On Tue, 24 Feb 2009 16:09:33 +0100, Michael Lawnick wrote:
>> >> The idea: when deferring the instantiation of the adapters of MUX1,
>> >> there should be something like a hot-plug event.
>> >> AFAIK, after adding an adapter via i2c_add_numbered_adapter(), the I2C
>> >> subsystem will probe for all currently known clients on this new bus.
>> >> Correct?
>> >> If so, this should cascade through the newly plugged in board.
>> > 
>> > For I2C chip drivers which do device autodetection (lm75 and eeprom are
>> > amongst them but for example at24 is not) yes. For other drivers (say
>> > at24) there should be a board definition for the new i2c bus segment.
>> 
>> I don't get the point here. The problem of correct identification will
>> have to be solved in any case.
> 
> I have no idea what you mean here, sorry. Correct identification of
> what?
> 
Probably I'm still hanging around with what you might call the legacy
model. When I started with I2C devices in LINUX, I supported the
I2C-device driver with possible I2C addresses in array normal_i2c[].
I2C Subsystem then called for every adapter and address
.attach_adapter->i2c_probe->myProbe() which tries to identify whether
the I2C device at given bus/address is really the applicable device.
myProbe() returned 0 or an error as an initialization and test result.
This was my starting point in this thread. You sound as if this no
longer supported to be used that way?!
Again I find me not understanding what the differences are between
'legacy' and 'new' model. :-(

...

> Alternatively, if you know the I2C bus number, you can get a pointer to
> the i2c_adapter in question using i2c_get_adapter(), and pass the
> result to i2c_new_device(). Don't forget to call i2c_put_adapter() when
> you're done.
> 
Ok, I will check.

...

> I think you really need to clear up you mind with the concepts of
> device and driver. There is no such thing as an "instance of a driver".
> When you load an I2C device driver module, there's (normally) only one
> driver that is registered, regardless of the number of current or
> future supported I2C devices in the system. I2C device instances (which
> we tend to name "I2C clients" in the Linux kernel) can then come and go
> at any point in time. Reloading the module has zero effect; it's
> neither required nor even useful.

What I call an instance is the equivalent of the resulting entry in
/sys/bus/i2c/devices
Adding a new entry on runtime for an already loaded I2C device driver
module is my quest.

> 
>> So far I have seen, the new model assumes a static network of devices
>> that can be initialized on boot strap. Information for this is taken
>> from device tree or kernel configuration data.
> 
> This is one of the 3 ways the new model can work, yes.
> 
And the other 2?

>> What I need is a user space initiated additional registration of a device.
> 
> While this could be implemented (see my short proposals above) I never
> meant it to be used beyond debugging or temporary workaround.
> Instantiating devices from user-space suggests that user-space knows
> things about the hardware which the kernel itself doesn't know, this
> doesn't sound exactly right.
> 
As hot plug isn't supported in I2C, it is the typical case that user
space is the first who knows that there is a new device.
Oh, probably I see the difference in our views: You might think of I2C
as a silly additional part of bigger devices. The initialization of the
big device then does include the announcement of the I2C sub part.
Well, I'm handling I2C as completely standalone system. There is no
bigger device. The I2C device is just mapped into sysFs, controlling is
done via user space applications. For me I2C is more like a bus system
like PCI, where devices get plugged in and out.

>> I have the typical S/W engineers problem: no H/W, no documentation, but
>> should design and implement a system that has to run out of the box when
>> first version of H/W arrives ;-)
> 
> And you have the additional typical problem that stubborn kernel
> subsystem maintainers can't read your mind and magically figure out
> what you need and implement it in the day.

;-) And therefore I'm searching for a tool to read the maintainer's mind
to find out what the code he made should work like. (Btw. this tool is
customarily called documentation |)
                                 V
> 
>> Therefore I asked for links in the OP so I can understand the idea of
>> the so called 'new I2C model'. The kernel documentation seems not to be
>> sufficient to achieve my goals.
...
-- 
Kind regards,
Michael

Re: Request for Clarification: old - legacy - new driver model

[Jean Delvare]

[-- Attachment #1: Type: text/plain, Size: 3815 bytes --]

Hi Michael,

On Fri, 27 Feb 2009 10:36:04 +0100, Michael Lawnick wrote:
> Jean Delvare said the following:
> > I have no idea what you mean here, sorry. Correct identification of
> > what?
>
> Probably I'm still hanging around with what you might call the legacy
> model. When I started with I2C devices in LINUX, I supported the
> I2C-device driver with possible I2C addresses in array normal_i2c[].
> I2C Subsystem then called for every adapter and address
> .attach_adapter->i2c_probe->myProbe() which tries to identify whether
> the I2C device at given bus/address is really the applicable device.
> myProbe() returned 0 or an error as an initialization and test result.
> This was my starting point in this thread. You sound as if this no
> longer supported to be used that way?!

It is supported in a slightly different form.

> Again I find me not understanding what the differences are between
> 'legacy' and 'new' model. :-(

Differences are so important that I don't know where to start ;)

> > (...)
> > I think you really need to clear up you mind with the concepts of
> > device and driver. There is no such thing as an "instance of a driver".
> > When you load an I2C device driver module, there's (normally) only one
> > driver that is registered, regardless of the number of current or
> > future supported I2C devices in the system. I2C device instances (which
> > we tend to name "I2C clients" in the Linux kernel) can then come and go
> > at any point in time. Reloading the module has zero effect; it's
> > neither required nor even useful.
> 
> What I call an instance is the equivalent of the resulting entry in
> /sys/bus/i2c/devices

OK, device instance then.

> Adding a new entry on runtime for an already loaded I2C device driver
> module is my quest.

This will be done automatically if the bus segment hosting the new I2C
device is properly registered and the device can be detected using ID
registers.

> > This is one of the 3 ways the new model can work, yes.
>
> And the other 2?

I wrote a document explaining the 3 available methods. I am attaching
it to this mail. Please read it. If it is clear enough, I plan to add
it to Documentation/i2c. If it's no clear enough, well, ask your
additional questions and I'll try to improve the document.

> >> What I need is a user space initiated additional registration of a device.
> > 
> > While this could be implemented (see my short proposals above) I never
> > meant it to be used beyond debugging or temporary workaround.
> > Instantiating devices from user-space suggests that user-space knows
> > things about the hardware which the kernel itself doesn't know, this
> > doesn't sound exactly right.
>
> As hot plug isn't supported in I2C, it is the typical case that user
> space is the first who knows that there is a new device.
> Oh, probably I see the difference in our views: You might think of I2C
> as a silly additional part of bigger devices. The initialization of the
> big device then does include the announcement of the I2C sub part.
> Well, I'm handling I2C as completely standalone system. There is no
> bigger device. The I2C device is just mapped into sysFs, controlling is
> done via user space applications. For me I2C is more like a bus system
> like PCI, where devices get plugged in and out.

I2C as a system bus is perfectly valid and supported. This is what many
embedded systems use.

I2C bus control (such as declaration of which devices are there)
through sysfs doesn't exist today, but could be added for cases such as
yours. I also can see the value of making mux drivers have a standard
sysfs interface to disable some channels, to allow hot-plug scenarios
such as yours. But I'd rather integrate Rodolfo's work as is first, and
add features later. Even that promises to be slow...

-- 
Jean Delvare

[-- Attachment #2: how-to-instantiate-i2c-devices.txt --]
[-- Type: text/plain, Size: 6207 bytes --]

How to instantiate I2C devices
==============================

Unlike PCI or USB devices, I2C devices are not enumerated at the hardware
level. Instead, the software must know which devices are connected on each
I2C bus segment, and what address these devices are using. For this
reason, the kernel code must instantiate I2C devices explicitly. There are
several ways to achieve this, depending on the context and requirements.


Method 1: Declare the I2C devices by bus number
-----------------------------------------------

This method is appropriate when the I2C bus is a system bus as is the case
for many embedded systems. On such systems, each I2C bus has a number
which is known in advance. It is thus possible to pre-declare the I2C
devices which live on this bus. This is done with an array of struct
i2c_board_info which is registered by calling i2c_register_board_info().

Example (from omap2 h4):

static struct i2c_board_info __initdata h4_i2c_board_info[] = {
	{
		I2C_BOARD_INFO("isp1301_omap", 0x2d),
		.irq		= OMAP_GPIO_IRQ(125),
	},
	{	/* EEPROM on mainboard */
		I2C_BOARD_INFO("24c01", 0x52),
		.platform_data	= &m24c01,
	},
	{	/* EEPROM on cpu card */
		I2C_BOARD_INFO("24c01", 0x57),
		.platform_data	= &m24c01,
	},
};

static void __init omap_h4_init(void)
{
	(...)
	i2c_register_board_info(1, h4_i2c_board_info,
			ARRAY_SIZE(h4_i2c_board_info));
	(...)
}

The above code declares 3 devices on I2C bus 1, including their respective
addresses and custom data needed by their drivers. When the I2C bus in
question is registered, the I2C devices will be instantiated automatically
by i2c-core.

The devices will be automatically unbound and destroyed when the I2C bus
they sit on goes away (if ever.)


Method 2: Instantiate the devices explicitly
--------------------------------------------

This method is appropriate when a larger device uses an I2C bus for
internal communication. A typical case is TV adapters. These can have a
tuner, a video decoder, an audio decoder, etc. usually connected to the
main chip by the means of an I2C bus. You won't know the number of the I2C
bus in advance, so the method 1 described above can't be used. Instead,
you can instantiate your I2C devices explicitly. This is done by filling
a struct i2c_board_info and calling i2c_new_device().

Example (from the sfe4001 network driver):

static struct i2c_board_info sfe4001_hwmon_info = {
	I2C_BOARD_INFO("max6647", 0x4e),
	.irq		= -1,
};

int sfe4001_init(struct efx_nic *efx)
{
	(...)
	efx->board_info.hwmon_client =
		i2c_new_device(&efx->i2c_adap, &sfe4001_hwmon_info);

	(...)
}

The above code instantiates 1 I2C device on the I2C bus which is on the
network adapter in question.

A variant of this is when you don't know for sure if an I2C device is
present or not (for example for an optional feature which is not present
on cheap variants of a board but you have no way to tell them apart), or
it may have different addresses from one board to the next (manufacturer
changing its design without notice). In this case, you can call
i2c_new_probed_device() instead of i2c_new_device().

Example (from the pnx4008 OHCI driver):

static const unsigned short normal_i2c[] = { 0x2c, 0x2d, I2C_CLIENT_END };

static int __devinit usb_hcd_pnx4008_probe(struct platform_device *pdev)
{
	(...)
	struct i2c_adapter *i2c_adap;
	struct i2c_board_info i2c_info;

	(...)
	i2c_adap = i2c_get_adapter(2);
	memset(&i2c_info, 0, sizeof(struct i2c_board_info));
	strlcpy(i2c_info.name, "isp1301_pnx", I2C_NAME_SIZE);
	isp1301_i2c_client = i2c_new_probed_device(i2c_adap, &i2c_info,
						   normal_i2c);
	i2c_put_adapter(i2c_adap);
	(...)
}

The above code instantiates up to 1 I2C device on the I2C bus which is on
the OHCI adapter in question. It first try at address 0x2c, if nothing is
found there it tries address 0x2d, and if still nothing is found, it
simply gives up.

The driver which instantiated the I2C device is responsible for destroying
it on cleanup. This is done by calling i2c_unregister_device() on the
pointer that was earlier returned by i2c_new_device() or
i2c_new_probed_device().


Method 3: Probe an I2C bus for certain devices
----------------------------------------------

Sometimes you do not have enough information about an I2C device, not even
to call i2c_new_probed_device(). The typical case is hardware monitoring
chips on PC mainboards. There are several dozen models, which can live
at 25 different addresses. Given the huge number of mainboards out there,
it is next to impossible to build an exhaustive list of the hardware
monitoring chips being used. Fortunately, most of these chips have
manufacturer and device ID registers, so they can be identified by
probing.

In that case, I2C devices are neither declared nor instantiated
explicitly. Instead, i2c-core will probe for such devices as soon as their
drivers are loaded, and if any is found, an I2C device will be
instantiated automatically. In order to prevent any misbehavior of this
mechanism, the following restrictions apply:
* The I2C device driver must implement the detect() method, which
  identifies a supported device by reading from arbitrary registers.
* Only buses which are likely to have a supported device and agree to be
  probed, will be probed. For example this avoids probing for hardware
  monitoring chips on a TV adapter.

Example:
See lm90_driver and lm90_detect() in drivers/hwmon/lm90.c

I2C devices instantiated as a result of such a successful probe will be
destroyed automatically when the driver which detected them is removed,
or when the underlying I2C bus is itself destroyed, whichever happens
first.

Those of you familiar with the i2c subsystem of 2.4 kernels and early 2.6
kernels will find out that this method 3 if essentially similar to what
was done there. Two significant differences are:
* Probing is only one way to instantiate I2C devices now, while it was the
  only way back then. Where possible, methods 1 and 2 should be preferred.
  Method 3 should only be used when there is no other way.
* I2C buses must now explicitly say which I2C driver classes can probe
  them (by the means of the class bitfield), while all I2C buses were
  probed by default back then.

Re: Request for Clarification: old - legacy - new driver model

[Michael Lawnick]

Hi Jean,

I have now got a 2.6.28.7 Kernel to play with on my board.
I assume I have to patch some files to get the same play ground as you,
right? Could you give me the msgIds/links?

Jean Delvare said the following:
> Hi Michael,
(...)
>> > This is one of the 3 ways the new model can work, yes.
>>
>> And the other 2?
> 
> I wrote a document explaining the 3 available methods. I am attaching
> it to this mail. Please read it. If it is clear enough, I plan to add
> it to Documentation/i2c. If it's no clear enough, well, ask your
> additional questions and I'll try to improve the document.
> 
Reads good. I'll ack your post from today.

(...)
> I2C bus control (such as declaration of which devices are there)
> through sysfs doesn't exist today, but could be added for cases such as
> yours. I also can see the value of making mux drivers have a standard
> sysfs interface to disable some channels, to allow hot-plug scenarios
> such as yours. But I'd rather integrate Rodolfo's work as is first, and
> add features later. Even that promises to be slow...

I'm currently thinking about making a module that allows to trigger
probing of buses, something like
insmod i2cDevProbe.ko "modname",busNo,devNo
Could finally be integrated into subsystem if there are more folks that
like it.
-- 
Regards,
Michael

Re: Request for Clarification: old - legacy - new driver model

[Jean Delvare]

On Mon, 09 Mar 2009 15:13:16 +0100, Michael Lawnick wrote:
> Hi Jean,
> 
> I have now got a 2.6.28.7 Kernel to play with on my board.
> I assume I have to patch some files to get the same play ground as you,
> right? Could you give me the msgIds/links?

Sorry but I don't quire follow you here. What play ground are you
talking about?

> Jean Delvare said the following:
> > Hi Michael,
> (...)
> >> > This is one of the 3 ways the new model can work, yes.
> >>
> >> And the other 2?
> > 
> > I wrote a document explaining the 3 available methods. I am attaching
> > it to this mail. Please read it. If it is clear enough, I plan to add
> > it to Documentation/i2c. If it's no clear enough, well, ask your
> > additional questions and I'll try to improve the document.
>
> Reads good. I'll ack your post from today.

Thank you!

> (...)
> > I2C bus control (such as declaration of which devices are there)
> > through sysfs doesn't exist today, but could be added for cases such as
> > yours. I also can see the value of making mux drivers have a standard
> > sysfs interface to disable some channels, to allow hot-plug scenarios
> > such as yours. But I'd rather integrate Rodolfo's work as is first, and
> > add features later. Even that promises to be slow...
> 
> I'm currently thinking about making a module that allows to trigger
> probing of buses, something like
> insmod i2cDevProbe.ko "modname",busNo,devNo
> Could finally be integrated into subsystem if there are more folks that
> like it.

I don't like the idea at all. Module parameters are not exactly a
convenient interface. As a matter of fact this is what we have today,
with the difference that the parameters are passed to relevant driver
directly rather than to a dedicated module (see the I2C_CLIENT_INSMOD*
macros in include/linux/i2c.h), and we are trying to move away from it
because they are highly user-unfriendly. What you propose is slightly
better than what we have in some respects, but that's not a significant
enough improvement to justify the move.

And your proposal has many drawbacks/lacks, too. For example, how do
you remove a device instance which you have created by mistake? How do
you create a new device instance when the i2cDevProbe.ko module is
already loaded? Just two problems off the top of my head, but there are
probably more.

I definitely prefer a sysfs-based approach as I initially mentioned,
this is much more flexible. If you have an urgent need for this
feature, we can add an action point to the wiki and start working on an
implementation. I suggest you start with creating your wiki account
then.

-- 
Jean Delvare

Re: Request for Clarification: old - legacy - new driver model

[Michael Lawnick]

Jean Delvare said the following:
> On Mon, 09 Mar 2009 15:13:16 +0100, Michael Lawnick wrote:
>> Hi Jean,
>> 
>> I have now got a 2.6.28.7 Kernel to play with on my board. I assume
>> I have to patch some files to get the same play ground as you, 
>> right? Could you give me the msgIds/links?
> 
> Sorry but I don't quire follow you here. What play ground are you 
> talking about?
>
I was talking about the version of I2C sub system you are currently
working on ...
Oh, I see, the patches of July are already in Kernel 2.6.28.7.

>> I'm currently thinking about making a module that allows to trigger
>>  probing of buses, something like insmod i2cDevProbe.ko
>> "modname",busNo,devNo Could finally be integrated into subsystem if
>> there are more folks that like it.
> 
> I don't like the idea at all.

I know :-D

> Module parameters are not exactly a convenient interface. As a matter
> of fact this is what we have today, with the difference that the
> parameters are passed to relevant driver directly rather than to a
> dedicated module (see the I2C_CLIENT_INSMOD* macros in
> include/linux/i2c.h), and we are trying to move away from it because
> they are highly user-unfriendly. What you propose is slightly better
> than what we have in some respects, but that's not a significant 
> enough improvement to justify the move.
> 
> And your proposal has many drawbacks/lacks, too. For example, how do 
> you remove a device instance which you have created by mistake? How
> do you create a new device instance when the i2cDevProbe.ko module is
>  already loaded? Just two problems off the top of my head, but there
> are probably more.
> 
Well, I currently don't see user space support in the way I need.
My module i2cDevProbe will do the probe/attach, a i2cDevDetach will do a
remove. Just as a first test version. The idea of module parameters was
not meant as the final solution.

> I definitely prefer a sysfs-based approach as I initially mentioned, 
> this is much more flexible. If you have an urgent need for this 
> feature, we can add an action point to the wiki and start working on
> an implementation. I suggest you start with creating your wiki
> account then.
> 
Incorporating such methods into subsystem would be much better of
course. Probably as a sysFs entry automatically added to every adapter
in /sys/class/i2c-adapter/i2c-x
AFAICS I will do this in the next weeks. Regarding wiki the other
question is whether I can take some official responsibility for such a
patch. I'm doing it as a professional, bound to a project. Further
development because of kernel changes in future wouldn't be supported in
sufficient way :-(

-- 
Regards,
Michael

Re: Request for Clarification: old - legacy - new driver model

[Michael Lawnick]

Sh** mailer GUI ...

Hi Jean,

Hmm, this one did not reach me via gmane ... something seems to be screwed up.
> Von: Jean Delvare <khali-PUYAD+kWke1g9hUCZPvPmw@public.gmane.org>
(...)
> > Incorporating such methods into subsystem would be much better of
> > course. Probably as a sysFs entry automatically added to every adapter
> > in /sys/class/i2c-adapter/i2c-x
> 
> Yes, this is exactly what I had in mind.
> 
So we finally meet ;-)
As this was my goal from the very beginning, I see that I will have to express myself more clearly.

(...)

> Contributing code today doesn't bind you to maintaining said code in
> the future. You really shouldn't have to worry about this. Once your
> code is upstream, the subsystem maintainer (i.e. me for i2c) will take
> care of maintaining it. Of course if you _do_ have time in the future
> to help with maintenance or contribute more code, this will be very
> welcome, but this is in no way mandatory.
> 
Based on this I don't see a problem.

-- 
Regards,
Michael
-- 
Psssst! Schon vom neuen GMX MultiMessenger gehört? Der kann`s mit allen: http://www.gmx.net/de/go/multimessenger01