| Message ID | 20220526205334.64114-2-eajames@linux.ibm.com |
|---|---|
| State | Superseded |
| Headers | show |
| Series | i2c: core: Add mux root adapter operations | expand |
On Thu, 26 May 2022 at 20:53, Eddie James <eajames@linux.ibm.com> wrote: > > Some I2C clients need the ability to control the root I2C bus even if the > endpoint device is behind a mux. For example, a driver for a chip that > can't handle any I2C traffic on the bus while coming out of reset > (including an I2C-driven mux switching channels) may need to lock the root > bus with the mux selection fixed for the entire time the device is in > reset. > For this purpose, add a new structure containing two function pointers to > the adapter structure. These functions pointers should be defined for > every adapter. The lock_select operation, for a mux adapter, locks the > parent adpaters up to the root and selects the adapter's channel. The > unlock_deselect operation deselects the mux channel and unlocks all the > adapters. For a non-mux adapter, the operations lock and unlock the > adapters up to the root. This scheme should work with multiple levels of > muxes and regular adapters in between. > > Signed-off-by: Eddie James <eajames@linux.ibm.com> I think this looks okay. It was hard to understand at first, but makes more sense with the context of the existing bus locking code. There's a typo in one of your comments that the 0day bot found. Have you tested with CONFIG_DEBUG_MUTEXES? Reviewed-by: Joel Stanley <joel@jms.id.au> > --- > drivers/i2c/i2c-core-base.c | 38 ++++++++++++++++++++++++++++ > drivers/i2c/i2c-mux.c | 50 +++++++++++++++++++++++++++++++++++++ > include/linux/i2c.h | 42 +++++++++++++++++++++++++++++++ > 3 files changed, 130 insertions(+) > > diff --git a/drivers/i2c/i2c-core-base.c b/drivers/i2c/i2c-core-base.c > index d43db2c3876e..e2c365348e1f 100644 > --- a/drivers/i2c/i2c-core-base.c > +++ b/drivers/i2c/i2c-core-base.c > @@ -1357,6 +1357,41 @@ static const struct i2c_lock_operations i2c_adapter_lock_ops = { > .unlock_bus = i2c_adapter_unlock_bus, > }; > > +/* > + * For a non-mux adapter, the lock_select operation locks the chain of > + * adapters upwards, returning the root. If there's a mux above this adapter > + * somehow, it should also get locked and the desired channel selected. > + */ Recursive lock the set of adaptors. > +static struct i2c_adapter *i2c_adapter_lock_select(struct i2c_adapter *adapter) > +{ > + struct i2c_adapter *ret = adapter; > + struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter); > + > + if (parent) { > + ret = parent->mux_root_ops->lock_select(parent); > + if (IS_ERR(ret)) > + return ret; > + } > + > + adapter->lock_ops->lock_bus(adapter, I2C_LOCK_ROOT_ADAPTER); > + return ret; > +} > + > +static void i2c_adapter_unlock_deselect(struct i2c_adapter *adapter) > +{ > + struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter); > + > + adapter->lock_ops->unlock_bus(adapter, I2C_LOCK_ROOT_ADAPTER); > + > + if (parent) > + parent->mux_root_ops->unlock_deselect(parent); > +} > + > +static const struct i2c_mux_root_operations i2c_adapter_mux_root_ops = { > + .lock_select = i2c_adapter_lock_select, > + .unlock_deselect = i2c_adapter_unlock_deselect, > +}; > + > static void i2c_host_notify_irq_teardown(struct i2c_adapter *adap) > { > struct irq_domain *domain = adap->host_notify_domain; > @@ -1452,6 +1487,9 @@ static int i2c_register_adapter(struct i2c_adapter *adap) > if (!adap->lock_ops) > adap->lock_ops = &i2c_adapter_lock_ops; > > + if (!adap->mux_root_ops) > + adap->mux_root_ops = &i2c_adapter_mux_root_ops; > + > adap->locked_flags = 0; > rt_mutex_init(&adap->bus_lock); > rt_mutex_init(&adap->mux_lock); > diff --git a/drivers/i2c/i2c-mux.c b/drivers/i2c/i2c-mux.c > index 774507b54b57..c7db770e4198 100644 > --- a/drivers/i2c/i2c-mux.c > +++ b/drivers/i2c/i2c-mux.c > @@ -210,6 +210,49 @@ static void i2c_parent_unlock_bus(struct i2c_adapter *adapter, > rt_mutex_unlock(&parent->mux_lock); > } > > +/* > + * For a mux adapter, the lock_select operation first locks just like the > + * lock_bus operation. Then it selects the channel for this adapter and > + * returns the root adapter. If there is another mux above this one, calling > + * the parent lock_select should ensure that the channel is correctly > + * selected. > + */ > +static struct i2c_adapter *i2c_mux_lock_select(struct i2c_adapter *adapter) > +{ > + int ret; > + struct i2c_mux_priv *priv = adapter->algo_data; > + struct i2c_mux_core *muxc = priv->muxc; > + struct i2c_adapter *parent = muxc->parent; > + > + rt_mutex_lock_nested(&parent->mux_lock, i2c_adapter_depth(adapter)); > + > + adapter = parent->mux_root_ops->lock_select(parent); > + if (IS_ERR(adapter)) > + return adapter; > + > + ret = muxc->select(muxc, priv->chan_id); > + if (ret < 0) { > + parent->mux_root_ops->unlock_deselect(parent); > + rt_mutex_unlock(&parent->mux_lock); > + return ERR_PTR(ret); > + } > + > + return adapter; > +} > + > +static void i2c_mux_unlock_deselect(struct i2c_adapter *adapter) > +{ > + struct i2c_mux_priv *priv = adapter->algo_data; > + struct i2c_mux_core *muxc = priv->muxc; > + struct i2c_adapter *parent = muxc->parent; > + > + if (muxc->deselect) > + muxc->deselect(muxc, priv->chan_id); > + > + parent->mux_root_ops->unlock_deselect(parent); > + rt_mutex_unlock(&parent->mux_lock); > +} > + > struct i2c_adapter *i2c_root_adapter(struct device *dev) > { > struct device *i2c; > @@ -279,6 +322,11 @@ static const struct i2c_lock_operations i2c_parent_lock_ops = { > .unlock_bus = i2c_parent_unlock_bus, > }; > > +static const struct i2c_mux_root_operations i2c_mux_root_ops = { > + .lock_select = i2c_mux_lock_select, > + .unlock_deselect = i2c_mux_unlock_deselect, > +}; > + > int i2c_mux_add_adapter(struct i2c_mux_core *muxc, > u32 force_nr, u32 chan_id, > unsigned int class) > @@ -339,6 +387,8 @@ int i2c_mux_add_adapter(struct i2c_mux_core *muxc, > else > priv->adap.lock_ops = &i2c_parent_lock_ops; > > + priv->adap.mux_root_ops = &i2c_mux_root_ops; > + > /* Sanity check on class */ > if (i2c_mux_parent_classes(parent) & class) > dev_err(&parent->dev, > diff --git a/include/linux/i2c.h b/include/linux/i2c.h > index fbda5ada2afc..a3596f61b417 100644 > --- a/include/linux/i2c.h > +++ b/include/linux/i2c.h > @@ -583,6 +583,26 @@ struct i2c_lock_operations { > void (*unlock_bus)(struct i2c_adapter *adapter, unsigned int flags); > }; > > +/** > + * struct i2c_mux_root_operations - represent operations to lock and select > + * the adapter's mux channel (if a mux is present) > + * @lock_select: Get exclusive access to the root I2C bus adapter with the > + * correct mux channel selected for the adapter > + * @unlock_deslect: Release exclusive access to the root I2C bus adapter and > + * deselect the mux channel for the adapter > + * > + * Some I2C clients need the ability to control the root I2C bus even if the > + * endpoint device is behind a mux. For example, a driver for a chip that > + * can't handle any I2C traffic on the bus while coming out of reset (including > + * an I2C-driven mux switching channels) may need to lock the root bus with > + * the mux selection fixed for the entire time the device is in reset. > + * These operations are for such a purpose. > + */ > +struct i2c_mux_root_operations { > + struct i2c_adapter *(*lock_select)(struct i2c_adapter *adapter); > + void (*unlock_deselect)(struct i2c_adapter *adapter); > +}; > + > /** > * struct i2c_timings - I2C timing information > * @bus_freq_hz: the bus frequency in Hz > @@ -725,6 +745,7 @@ struct i2c_adapter { > > /* data fields that are valid for all devices */ > const struct i2c_lock_operations *lock_ops; > + const struct i2c_mux_root_operations *mux_root_ops; > struct rt_mutex bus_lock; > struct rt_mutex mux_lock; > > @@ -817,6 +838,27 @@ i2c_unlock_bus(struct i2c_adapter *adapter, unsigned int flags) > adapter->lock_ops->unlock_bus(adapter, flags); > } > > +/** > + * i2c_lock_select_bus - Get exclusive access to the root I2C bus with the > + * target's mux channel (if a mux is present) selected. > + * @adapter: Target I2C bus > + * > + * Return the root I2C bus if mux selection succeeds, an ERR_PTR otherwise > + */ > +static inline struct i2c_adapter *i2c_lock_select_bus(struct i2c_adapter *adapter) > +{ > + return adapter->mux_root_ops->lock_select(adapter); > +} > + > +/** > + * i2c_unlock_deslect_bus - Release exclusive access to the root I2C bus > + * @adapter: Target I2C bus > + */ > +static inline void i2c_unlock_deselect_bus(struct i2c_adapter *adapter) > +{ > + adapter->mux_root_ops->unlock_deselect(adapter); > +} > + > /** > * i2c_mark_adapter_suspended - Report suspended state of the adapter to the core > * @adap: Adapter to mark as suspended > -- > 2.27.0 >
On 6/3/22 03:01, Joel Stanley wrote: > On Thu, 26 May 2022 at 20:53, Eddie James <eajames@linux.ibm.com> wrote: >> Some I2C clients need the ability to control the root I2C bus even if the >> endpoint device is behind a mux. For example, a driver for a chip that >> can't handle any I2C traffic on the bus while coming out of reset >> (including an I2C-driven mux switching channels) may need to lock the root >> bus with the mux selection fixed for the entire time the device is in >> reset. >> For this purpose, add a new structure containing two function pointers to >> the adapter structure. These functions pointers should be defined for >> every adapter. The lock_select operation, for a mux adapter, locks the >> parent adpaters up to the root and selects the adapter's channel. The >> unlock_deselect operation deselects the mux channel and unlocks all the >> adapters. For a non-mux adapter, the operations lock and unlock the >> adapters up to the root. This scheme should work with multiple levels of >> muxes and regular adapters in between. >> >> Signed-off-by: Eddie James <eajames@linux.ibm.com> > I think this looks okay. It was hard to understand at first, but makes > more sense with the context of the existing bus locking code. > > There's a typo in one of your comments that the 0day bot found. > > Have you tested with CONFIG_DEBUG_MUTEXES? Getting back around to this... Yes, I just tested with CONFIG_DEBUG_MUTEXES and didn't see any issues. I will address the comment typo in v2 now. Thanks, Eddie > > Reviewed-by: Joel Stanley <joel@jms.id.au> > >> --- >> drivers/i2c/i2c-core-base.c | 38 ++++++++++++++++++++++++++++ >> drivers/i2c/i2c-mux.c | 50 +++++++++++++++++++++++++++++++++++++ >> include/linux/i2c.h | 42 +++++++++++++++++++++++++++++++ >> 3 files changed, 130 insertions(+) >> >> diff --git a/drivers/i2c/i2c-core-base.c b/drivers/i2c/i2c-core-base.c >> index d43db2c3876e..e2c365348e1f 100644 >> --- a/drivers/i2c/i2c-core-base.c >> +++ b/drivers/i2c/i2c-core-base.c >> @@ -1357,6 +1357,41 @@ static const struct i2c_lock_operations i2c_adapter_lock_ops = { >> .unlock_bus = i2c_adapter_unlock_bus, >> }; >> >> +/* >> + * For a non-mux adapter, the lock_select operation locks the chain of >> + * adapters upwards, returning the root. If there's a mux above this adapter >> + * somehow, it should also get locked and the desired channel selected. >> + */ > Recursive lock the set of adaptors. > >> +static struct i2c_adapter *i2c_adapter_lock_select(struct i2c_adapter *adapter) >> +{ >> + struct i2c_adapter *ret = adapter; >> + struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter); >> + >> + if (parent) { >> + ret = parent->mux_root_ops->lock_select(parent); >> + if (IS_ERR(ret)) >> + return ret; >> + } >> + >> + adapter->lock_ops->lock_bus(adapter, I2C_LOCK_ROOT_ADAPTER); >> + return ret; >> +} >> + >> +static void i2c_adapter_unlock_deselect(struct i2c_adapter *adapter) >> +{ >> + struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter); >> + >> + adapter->lock_ops->unlock_bus(adapter, I2C_LOCK_ROOT_ADAPTER); >> + >> + if (parent) >> + parent->mux_root_ops->unlock_deselect(parent); >> +} >> + >> +static const struct i2c_mux_root_operations i2c_adapter_mux_root_ops = { >> + .lock_select = i2c_adapter_lock_select, >> + .unlock_deselect = i2c_adapter_unlock_deselect, >> +}; >> + >> static void i2c_host_notify_irq_teardown(struct i2c_adapter *adap) >> { >> struct irq_domain *domain = adap->host_notify_domain; >> @@ -1452,6 +1487,9 @@ static int i2c_register_adapter(struct i2c_adapter *adap) >> if (!adap->lock_ops) >> adap->lock_ops = &i2c_adapter_lock_ops; >> >> + if (!adap->mux_root_ops) >> + adap->mux_root_ops = &i2c_adapter_mux_root_ops; >> + >> adap->locked_flags = 0; >> rt_mutex_init(&adap->bus_lock); >> rt_mutex_init(&adap->mux_lock); >> diff --git a/drivers/i2c/i2c-mux.c b/drivers/i2c/i2c-mux.c >> index 774507b54b57..c7db770e4198 100644 >> --- a/drivers/i2c/i2c-mux.c >> +++ b/drivers/i2c/i2c-mux.c >> @@ -210,6 +210,49 @@ static void i2c_parent_unlock_bus(struct i2c_adapter *adapter, >> rt_mutex_unlock(&parent->mux_lock); >> } >> >> +/* >> + * For a mux adapter, the lock_select operation first locks just like the >> + * lock_bus operation. Then it selects the channel for this adapter and >> + * returns the root adapter. If there is another mux above this one, calling >> + * the parent lock_select should ensure that the channel is correctly >> + * selected. >> + */ >> +static struct i2c_adapter *i2c_mux_lock_select(struct i2c_adapter *adapter) >> +{ >> + int ret; >> + struct i2c_mux_priv *priv = adapter->algo_data; >> + struct i2c_mux_core *muxc = priv->muxc; >> + struct i2c_adapter *parent = muxc->parent; >> + >> + rt_mutex_lock_nested(&parent->mux_lock, i2c_adapter_depth(adapter)); >> + >> + adapter = parent->mux_root_ops->lock_select(parent); >> + if (IS_ERR(adapter)) >> + return adapter; >> + >> + ret = muxc->select(muxc, priv->chan_id); >> + if (ret < 0) { >> + parent->mux_root_ops->unlock_deselect(parent); >> + rt_mutex_unlock(&parent->mux_lock); >> + return ERR_PTR(ret); >> + } >> + >> + return adapter; >> +} >> + >> +static void i2c_mux_unlock_deselect(struct i2c_adapter *adapter) >> +{ >> + struct i2c_mux_priv *priv = adapter->algo_data; >> + struct i2c_mux_core *muxc = priv->muxc; >> + struct i2c_adapter *parent = muxc->parent; >> + >> + if (muxc->deselect) >> + muxc->deselect(muxc, priv->chan_id); >> + >> + parent->mux_root_ops->unlock_deselect(parent); >> + rt_mutex_unlock(&parent->mux_lock); >> +} >> + >> struct i2c_adapter *i2c_root_adapter(struct device *dev) >> { >> struct device *i2c; >> @@ -279,6 +322,11 @@ static const struct i2c_lock_operations i2c_parent_lock_ops = { >> .unlock_bus = i2c_parent_unlock_bus, >> }; >> >> +static const struct i2c_mux_root_operations i2c_mux_root_ops = { >> + .lock_select = i2c_mux_lock_select, >> + .unlock_deselect = i2c_mux_unlock_deselect, >> +}; >> + >> int i2c_mux_add_adapter(struct i2c_mux_core *muxc, >> u32 force_nr, u32 chan_id, >> unsigned int class) >> @@ -339,6 +387,8 @@ int i2c_mux_add_adapter(struct i2c_mux_core *muxc, >> else >> priv->adap.lock_ops = &i2c_parent_lock_ops; >> >> + priv->adap.mux_root_ops = &i2c_mux_root_ops; >> + >> /* Sanity check on class */ >> if (i2c_mux_parent_classes(parent) & class) >> dev_err(&parent->dev, >> diff --git a/include/linux/i2c.h b/include/linux/i2c.h >> index fbda5ada2afc..a3596f61b417 100644 >> --- a/include/linux/i2c.h >> +++ b/include/linux/i2c.h >> @@ -583,6 +583,26 @@ struct i2c_lock_operations { >> void (*unlock_bus)(struct i2c_adapter *adapter, unsigned int flags); >> }; >> >> +/** >> + * struct i2c_mux_root_operations - represent operations to lock and select >> + * the adapter's mux channel (if a mux is present) >> + * @lock_select: Get exclusive access to the root I2C bus adapter with the >> + * correct mux channel selected for the adapter >> + * @unlock_deslect: Release exclusive access to the root I2C bus adapter and >> + * deselect the mux channel for the adapter >> + * >> + * Some I2C clients need the ability to control the root I2C bus even if the >> + * endpoint device is behind a mux. For example, a driver for a chip that >> + * can't handle any I2C traffic on the bus while coming out of reset (including >> + * an I2C-driven mux switching channels) may need to lock the root bus with >> + * the mux selection fixed for the entire time the device is in reset. >> + * These operations are for such a purpose. >> + */ >> +struct i2c_mux_root_operations { >> + struct i2c_adapter *(*lock_select)(struct i2c_adapter *adapter); >> + void (*unlock_deselect)(struct i2c_adapter *adapter); >> +}; >> + >> /** >> * struct i2c_timings - I2C timing information >> * @bus_freq_hz: the bus frequency in Hz >> @@ -725,6 +745,7 @@ struct i2c_adapter { >> >> /* data fields that are valid for all devices */ >> const struct i2c_lock_operations *lock_ops; >> + const struct i2c_mux_root_operations *mux_root_ops; >> struct rt_mutex bus_lock; >> struct rt_mutex mux_lock; >> >> @@ -817,6 +838,27 @@ i2c_unlock_bus(struct i2c_adapter *adapter, unsigned int flags) >> adapter->lock_ops->unlock_bus(adapter, flags); >> } >> >> +/** >> + * i2c_lock_select_bus - Get exclusive access to the root I2C bus with the >> + * target's mux channel (if a mux is present) selected. >> + * @adapter: Target I2C bus >> + * >> + * Return the root I2C bus if mux selection succeeds, an ERR_PTR otherwise >> + */ >> +static inline struct i2c_adapter *i2c_lock_select_bus(struct i2c_adapter *adapter) >> +{ >> + return adapter->mux_root_ops->lock_select(adapter); >> +} >> + >> +/** >> + * i2c_unlock_deslect_bus - Release exclusive access to the root I2C bus >> + * @adapter: Target I2C bus >> + */ >> +static inline void i2c_unlock_deselect_bus(struct i2c_adapter *adapter) >> +{ >> + adapter->mux_root_ops->unlock_deselect(adapter); >> +} >> + >> /** >> * i2c_mark_adapter_suspended - Report suspended state of the adapter to the core >> * @adap: Adapter to mark as suspended >> -- >> 2.27.0 >>
diff --git a/drivers/i2c/i2c-core-base.c b/drivers/i2c/i2c-core-base.c index d43db2c3876e..e2c365348e1f 100644 --- a/drivers/i2c/i2c-core-base.c +++ b/drivers/i2c/i2c-core-base.c @@ -1357,6 +1357,41 @@ static const struct i2c_lock_operations i2c_adapter_lock_ops = { .unlock_bus = i2c_adapter_unlock_bus, }; +/* + * For a non-mux adapter, the lock_select operation locks the chain of + * adapters upwards, returning the root. If there's a mux above this adapter + * somehow, it should also get locked and the desired channel selected. + */ +static struct i2c_adapter *i2c_adapter_lock_select(struct i2c_adapter *adapter) +{ + struct i2c_adapter *ret = adapter; + struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter); + + if (parent) { + ret = parent->mux_root_ops->lock_select(parent); + if (IS_ERR(ret)) + return ret; + } + + adapter->lock_ops->lock_bus(adapter, I2C_LOCK_ROOT_ADAPTER); + return ret; +} + +static void i2c_adapter_unlock_deselect(struct i2c_adapter *adapter) +{ + struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter); + + adapter->lock_ops->unlock_bus(adapter, I2C_LOCK_ROOT_ADAPTER); + + if (parent) + parent->mux_root_ops->unlock_deselect(parent); +} + +static const struct i2c_mux_root_operations i2c_adapter_mux_root_ops = { + .lock_select = i2c_adapter_lock_select, + .unlock_deselect = i2c_adapter_unlock_deselect, +}; + static void i2c_host_notify_irq_teardown(struct i2c_adapter *adap) { struct irq_domain *domain = adap->host_notify_domain; @@ -1452,6 +1487,9 @@ static int i2c_register_adapter(struct i2c_adapter *adap) if (!adap->lock_ops) adap->lock_ops = &i2c_adapter_lock_ops; + if (!adap->mux_root_ops) + adap->mux_root_ops = &i2c_adapter_mux_root_ops; + adap->locked_flags = 0; rt_mutex_init(&adap->bus_lock); rt_mutex_init(&adap->mux_lock); diff --git a/drivers/i2c/i2c-mux.c b/drivers/i2c/i2c-mux.c index 774507b54b57..c7db770e4198 100644 --- a/drivers/i2c/i2c-mux.c +++ b/drivers/i2c/i2c-mux.c @@ -210,6 +210,49 @@ static void i2c_parent_unlock_bus(struct i2c_adapter *adapter, rt_mutex_unlock(&parent->mux_lock); } +/* + * For a mux adapter, the lock_select operation first locks just like the + * lock_bus operation. Then it selects the channel for this adapter and + * returns the root adapter. If there is another mux above this one, calling + * the parent lock_select should ensure that the channel is correctly + * selected. + */ +static struct i2c_adapter *i2c_mux_lock_select(struct i2c_adapter *adapter) +{ + int ret; + struct i2c_mux_priv *priv = adapter->algo_data; + struct i2c_mux_core *muxc = priv->muxc; + struct i2c_adapter *parent = muxc->parent; + + rt_mutex_lock_nested(&parent->mux_lock, i2c_adapter_depth(adapter)); + + adapter = parent->mux_root_ops->lock_select(parent); + if (IS_ERR(adapter)) + return adapter; + + ret = muxc->select(muxc, priv->chan_id); + if (ret < 0) { + parent->mux_root_ops->unlock_deselect(parent); + rt_mutex_unlock(&parent->mux_lock); + return ERR_PTR(ret); + } + + return adapter; +} + +static void i2c_mux_unlock_deselect(struct i2c_adapter *adapter) +{ + struct i2c_mux_priv *priv = adapter->algo_data; + struct i2c_mux_core *muxc = priv->muxc; + struct i2c_adapter *parent = muxc->parent; + + if (muxc->deselect) + muxc->deselect(muxc, priv->chan_id); + + parent->mux_root_ops->unlock_deselect(parent); + rt_mutex_unlock(&parent->mux_lock); +} + struct i2c_adapter *i2c_root_adapter(struct device *dev) { struct device *i2c; @@ -279,6 +322,11 @@ static const struct i2c_lock_operations i2c_parent_lock_ops = { .unlock_bus = i2c_parent_unlock_bus, }; +static const struct i2c_mux_root_operations i2c_mux_root_ops = { + .lock_select = i2c_mux_lock_select, + .unlock_deselect = i2c_mux_unlock_deselect, +}; + int i2c_mux_add_adapter(struct i2c_mux_core *muxc, u32 force_nr, u32 chan_id, unsigned int class) @@ -339,6 +387,8 @@ int i2c_mux_add_adapter(struct i2c_mux_core *muxc, else priv->adap.lock_ops = &i2c_parent_lock_ops; + priv->adap.mux_root_ops = &i2c_mux_root_ops; + /* Sanity check on class */ if (i2c_mux_parent_classes(parent) & class) dev_err(&parent->dev, diff --git a/include/linux/i2c.h b/include/linux/i2c.h index fbda5ada2afc..a3596f61b417 100644 --- a/include/linux/i2c.h +++ b/include/linux/i2c.h @@ -583,6 +583,26 @@ struct i2c_lock_operations { void (*unlock_bus)(struct i2c_adapter *adapter, unsigned int flags); }; +/** + * struct i2c_mux_root_operations - represent operations to lock and select + * the adapter's mux channel (if a mux is present) + * @lock_select: Get exclusive access to the root I2C bus adapter with the + * correct mux channel selected for the adapter + * @unlock_deslect: Release exclusive access to the root I2C bus adapter and + * deselect the mux channel for the adapter + * + * Some I2C clients need the ability to control the root I2C bus even if the + * endpoint device is behind a mux. For example, a driver for a chip that + * can't handle any I2C traffic on the bus while coming out of reset (including + * an I2C-driven mux switching channels) may need to lock the root bus with + * the mux selection fixed for the entire time the device is in reset. + * These operations are for such a purpose. + */ +struct i2c_mux_root_operations { + struct i2c_adapter *(*lock_select)(struct i2c_adapter *adapter); + void (*unlock_deselect)(struct i2c_adapter *adapter); +}; + /** * struct i2c_timings - I2C timing information * @bus_freq_hz: the bus frequency in Hz @@ -725,6 +745,7 @@ struct i2c_adapter { /* data fields that are valid for all devices */ const struct i2c_lock_operations *lock_ops; + const struct i2c_mux_root_operations *mux_root_ops; struct rt_mutex bus_lock; struct rt_mutex mux_lock; @@ -817,6 +838,27 @@ i2c_unlock_bus(struct i2c_adapter *adapter, unsigned int flags) adapter->lock_ops->unlock_bus(adapter, flags); } +/** + * i2c_lock_select_bus - Get exclusive access to the root I2C bus with the + * target's mux channel (if a mux is present) selected. + * @adapter: Target I2C bus + * + * Return the root I2C bus if mux selection succeeds, an ERR_PTR otherwise + */ +static inline struct i2c_adapter *i2c_lock_select_bus(struct i2c_adapter *adapter) +{ + return adapter->mux_root_ops->lock_select(adapter); +} + +/** + * i2c_unlock_deslect_bus - Release exclusive access to the root I2C bus + * @adapter: Target I2C bus + */ +static inline void i2c_unlock_deselect_bus(struct i2c_adapter *adapter) +{ + adapter->mux_root_ops->unlock_deselect(adapter); +} + /** * i2c_mark_adapter_suspended - Report suspended state of the adapter to the core * @adap: Adapter to mark as suspended
Some I2C clients need the ability to control the root I2C bus even if the endpoint device is behind a mux. For example, a driver for a chip that can't handle any I2C traffic on the bus while coming out of reset (including an I2C-driven mux switching channels) may need to lock the root bus with the mux selection fixed for the entire time the device is in reset. For this purpose, add a new structure containing two function pointers to the adapter structure. These functions pointers should be defined for every adapter. The lock_select operation, for a mux adapter, locks the parent adpaters up to the root and selects the adapter's channel. The unlock_deselect operation deselects the mux channel and unlocks all the adapters. For a non-mux adapter, the operations lock and unlock the adapters up to the root. This scheme should work with multiple levels of muxes and regular adapters in between. Signed-off-by: Eddie James <eajames@linux.ibm.com> --- drivers/i2c/i2c-core-base.c | 38 ++++++++++++++++++++++++++++ drivers/i2c/i2c-mux.c | 50 +++++++++++++++++++++++++++++++++++++ include/linux/i2c.h | 42 +++++++++++++++++++++++++++++++ 3 files changed, 130 insertions(+)