From nobody Tue Dec 16 23:46:37 2025 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id D072DC3DA6F for ; Thu, 24 Aug 2023 12:18:38 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S241326AbjHXMSK (ORCPT ); Thu, 24 Aug 2023 08:18:10 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:34444 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S241379AbjHXMSG (ORCPT ); Thu, 24 Aug 2023 08:18:06 -0400 Received: from mail-yw1-x1149.google.com (mail-yw1-x1149.google.com [IPv6:2607:f8b0:4864:20::1149]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 98F8910EF for ; Thu, 24 Aug 2023 05:18:04 -0700 (PDT) Received: by mail-yw1-x1149.google.com with SMTP id 00721157ae682-58f9db8bc1dso82101967b3.3 for ; Thu, 24 Aug 2023 05:18:04 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20221208; t=1692879484; x=1693484284; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=0vOYxGK8LX/cV5k4gTSBXuorx7IhaaE1lnGQ1Odm1SE=; b=xd+lCiVyQzhEx/p/bpyURAxztpZwJF8yzbaYFneXbr4b6r/g/4xXIep9MVZFI/sDU2 glWCTGXk4FJ+3pNPKMe/K/wfkYmqfZClWc5F8aR413AKqPCFcyB2wpXyuMY4Lbv6QAFF 3hRTlht2opQSuBZdg6TtDnQlSjXqikbzRicRgWf0VaWeKzpwm018XBPgvwsAvuE197BL jxDbakU617zyQmDFRbCEsrMQmdm1oFeW4Yr0DF8QnJ9OXzysHNjUJ39VidVTADXzh3Kf tl51/OZFHX2NpuuLibEVb71kJdqmz6psC0s4F0AysWHL431aP3N1vLxy3Mch9EV1W1UL SHyw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1692879484; x=1693484284; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=0vOYxGK8LX/cV5k4gTSBXuorx7IhaaE1lnGQ1Odm1SE=; b=CD/C9kWZR88L5l1n+QHwCFiY7i9dWEftqL8Mwxw9YaVGppJNujZujsMhcMoq0CgeDG kSRnsixxi0LdF6VCEibSRZMynUT9gNOAF913rYKv7v9/m/hHn0LJmRj7thJUSZxLMwBa Hv5MRf2wFpmCVWhem/LM9crvlkp4Kd017eKV1JoJTx1tm+XgPhW4VL/r6enU4ykXnX3O w1AnZM30SoZVoPrIftR5d7toS7oohdHb+xn+5ei2xW/iTT+MZD3CxEBGCz5EsOTi+YrK Usqr1sQDSAWf5j0iv6abXCk/ZhFEis0U3TztM+PDjLgMTOP7FV8i3HcHOTnKoW7Qn+Ui cX+A== X-Gm-Message-State: AOJu0YxGfDQbamnMraP0x1NnaC4/xAk+4EhVDzs2CN52iwkAVTCEbNQb lRK4Spr4knM1XDprsOz7iUetwDUTtrKFPVVVClk= X-Google-Smtp-Source: AGHT+IE/zaxCN5ez0VrtY/hjhlbCvv+NBrf/ugGdZTAQGzZHLKPBlCKcxpu9no3FjkfZzH9mjVHcxDf660TMyjSIu8U= X-Received: from anikett.c.googlers.com ([fda3:e722:ac3:cc00:4f:4b78:c0a8:2551]) (user=aniketmaurya job=sendgmr) by 2002:a81:430d:0:b0:576:fdbe:76b2 with SMTP id q13-20020a81430d000000b00576fdbe76b2mr220141ywa.3.1692879483884; Thu, 24 Aug 2023 05:18:03 -0700 (PDT) Date: Thu, 24 Aug 2023 12:17:49 +0000 In-Reply-To: <20230824121750.1673566-1-aniketmaurya@google.com> Mime-Version: 1.0 References: <20230824121750.1673566-1-aniketmaurya@google.com> X-Mailer: git-send-email 2.42.0.rc1.204.g551eb34607-goog Message-ID: <20230824121750.1673566-2-aniketmaurya@google.com> Subject: [PATCH v1 1/2] mux: Add support for handling array of mux-state From: Aniket To: Peter Rosin Cc: linux-kernel@vger.kernel.org, joychakr@google.com, Aniket Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Sometimes consumer needs to manage a number of mux- states, so it is easier if they can control it using an array of such mux-states. Add support to devm_get, select and deselect the array. Signed-off-by: Aniket --- drivers/mux/core.c | 161 +++++++++++++++++++++++++++++++++-- include/linux/mux/consumer.h | 7 ++ 2 files changed, 162 insertions(+), 6 deletions(-) diff --git a/drivers/mux/core.c b/drivers/mux/core.c index 990e7bc17c85..e4e57847e904 100644 --- a/drivers/mux/core.c +++ b/drivers/mux/core.c @@ -43,6 +43,16 @@ struct mux_state { unsigned int state; }; =20 +/** + * struct mux_state_array - Represents an array of mux states + * @num: number of mux state + * @mstate: array of mux states + */ +struct mux_state_array { + unsigned int num; + struct mux_state *mstate[]; +}; + static struct class mux_class =3D { .name =3D "mux", }; @@ -408,6 +418,44 @@ int mux_state_select_delay(struct mux_state *mstate, u= nsigned int delay_us) } EXPORT_SYMBOL_GPL(mux_state_select_delay); =20 +/** + * mux_state_array_select() - Select the given multiplexer state. + * @mstates: The mux-state-array which contains multiple mux-state to sele= ct. + * + * On successfully selecting all the mux-states, their mux-control will be + * locked until there is a call to mux_state_array_deselect(). + * If a mux-controls is already selected when mux_state_array_select() is + * called, then caller will be blocked. + * + * Therefore, make sure to call mux_state_array_deselect() when the operat= ion + * is complete and the mux-state-array is free for others to use, but do n= ot + * call mux_state_array_deselect() if mux_state_array_select() fails. + * If a mux_state_array_select() fails inbetween the already selected + * mux-states in the array are deselected. + * + * Return: 0 when the mux-state has been selected or a negative + * errno on error. + */ +int mux_state_array_select(struct mux_state_array *mstates) +{ + int ret, i; + + for (i =3D 0; i < mstates->num; ++i) { + ret =3D mux_state_select(mstates->mstate[i]); + if (ret < 0) + goto err_mstates; + } + + return 0; + +err_mstates: + while (--i >=3D 0) + mux_state_deselect(mstates->mstate[i]); + + return ret; +} +EXPORT_SYMBOL_GPL(mux_state_array_select); + /** * mux_control_try_select_delay() - Try to select the given multiplexer st= ate. * @mux: The mux-control to request a change of state from. @@ -508,6 +556,29 @@ int mux_state_deselect(struct mux_state *mstate) } EXPORT_SYMBOL_GPL(mux_state_deselect); =20 +/** + * mux_state_array_deselect() - Deselect the previously selected multiplex= er state. + * @mstates: Array of mux-states to deselect. + * + * It is required that a single call is made to mux_state_array_deselect()= for + * each and every successful call made to either of mux_state_array_select= (). + * + * Return: 0 on success and a negative errno on error. + */ +int mux_state_array_deselect(struct mux_state_array *mstates) +{ + int ret, i; + + for (i =3D 0; i < mstates->num; ++i) { + ret =3D mux_state_deselect(mstates->mstate[i]); + if (ret < 0) + return ret; + } + + return 0; +} +EXPORT_SYMBOL_GPL(mux_state_array_deselect); + /* Note this function returns a reference to the mux_chip dev. */ static struct mux_chip *of_find_mux_chip_by_node(struct device_node *np) { @@ -522,19 +593,19 @@ static struct mux_chip *of_find_mux_chip_by_node(stru= ct device_node *np) * mux_get() - Get the mux-control for a device. * @dev: The device that needs a mux-control. * @mux_name: The name identifying the mux-control. + * @index: Index to identify mux-control if mux-name is NULL. * @state: Pointer to where the requested state is returned, or NULL when * the required multiplexer states are handled by other means. * * Return: A pointer to the mux-control, or an ERR_PTR with a negative err= no. */ static struct mux_control *mux_get(struct device *dev, const char *mux_nam= e, - unsigned int *state) + int index, unsigned int *state) { struct device_node *np =3D dev->of_node; struct of_phandle_args args; struct mux_chip *mux_chip; unsigned int controller; - int index =3D 0; int ret; =20 if (mux_name) { @@ -619,7 +690,7 @@ static struct mux_control *mux_get(struct device *dev, = const char *mux_name, */ struct mux_control *mux_control_get(struct device *dev, const char *mux_na= me) { - return mux_get(dev, mux_name, NULL); + return mux_get(dev, mux_name, 0, NULL); } EXPORT_SYMBOL_GPL(mux_control_get); =20 @@ -676,10 +747,12 @@ EXPORT_SYMBOL_GPL(devm_mux_control_get); * mux_state_get() - Get the mux-state for a device. * @dev: The device that needs a mux-state. * @mux_name: The name identifying the mux-state. + * @index: Index of the mux-state, to be used when mux-name is NULL * * Return: A pointer to the mux-state, or an ERR_PTR with a negative errno. */ -static struct mux_state *mux_state_get(struct device *dev, const char *mux= _name) +static struct mux_state *mux_state_get(struct device *dev, const char *mux= _name, + int index) { struct mux_state *mstate; =20 @@ -687,7 +760,7 @@ static struct mux_state *mux_state_get(struct device *d= ev, const char *mux_name) if (!mstate) return ERR_PTR(-ENOMEM); =20 - mstate->mux =3D mux_get(dev, mux_name, &mstate->state); + mstate->mux =3D mux_get(dev, mux_name, index, &mstate->state); if (IS_ERR(mstate->mux)) { int err =3D PTR_ERR(mstate->mux); =20 @@ -734,7 +807,7 @@ struct mux_state *devm_mux_state_get(struct device *dev, if (!ptr) return ERR_PTR(-ENOMEM); =20 - mstate =3D mux_state_get(dev, mux_name); + mstate =3D mux_state_get(dev, mux_name, 0); if (IS_ERR(mstate)) { devres_free(ptr); return mstate; @@ -747,6 +820,82 @@ struct mux_state *devm_mux_state_get(struct device *de= v, } EXPORT_SYMBOL_GPL(devm_mux_state_get); =20 +/* + * mux_state_array_get() - Get the all the mux-states for a device. + * @dev: The device that needs a mux-state. + * + * Return: A pointer to the mux-state, or an ERR_PTR with a negative errno. + */ +static struct mux_state_array *mux_state_array_get(struct device *dev) +{ + struct mux_state_array *mstates; + struct mux_state *mstate; + int num, i; + + num =3D of_count_phandle_with_args(dev->of_node, "mux-states", "#mux-stat= e-cells"); + if (num < 0) + return ERR_PTR(num); + + mstates =3D kzalloc(struct_size(mstates, mstate, num), GFP_KERNEL); + if (!mstates) + return ERR_PTR(-ENOMEM); + + for (i =3D 0; i < num; i++) { + mstate =3D mux_state_get(dev, NULL, i); + if (IS_ERR(mstate)) + goto err_mstates; + mstates->mstate[i] =3D mstate; + } + mstates->num =3D num; + + return mstates; + +err_mstates: + while (--i >=3D 0) + mux_state_put(mstates->mstate[i]); + kfree(mstates); + + return ERR_PTR(PTR_ERR(mstate)); +} + +static void devm_mux_state_array_release(struct device *dev, void *res) +{ + int i; + struct mux_state_array *mstates =3D *(struct mux_state_array **)res; + + for (i =3D 0; i < mstates->num; i++) + mux_state_put(mstates->mstate[i]); + kfree(mstates); +} + +/** + * devm_mux_state_array_get() - Get the all the mux-states for a device, w= ith + * resource management. + * @dev: The device that needs a mux-control. + * + * Return: Pointer to the mux-state-array, or an ERR_PTR with a negative e= rrno. + */ +struct mux_state_array *devm_mux_state_array_get(struct device *dev) +{ + struct mux_state_array **ptr, *mstates; + + ptr =3D devres_alloc(devm_mux_state_array_release, sizeof(*ptr), GFP_KERN= EL); + if (!ptr) + return ERR_PTR(-ENOMEM); + + mstates =3D mux_state_array_get(dev); + if (IS_ERR(mstates)) { + devres_free(ptr); + return mstates; + } + + *ptr =3D mstates; + devres_add(dev, ptr); + + return mstates; +} +EXPORT_SYMBOL_GPL(devm_mux_state_array_get); + /* * Using subsys_initcall instead of module_init here to try to ensure - for * the non-modular case - that the subsystem is initialized when mux consu= mers diff --git a/include/linux/mux/consumer.h b/include/linux/mux/consumer.h index 2e25c838f831..da15d0542008 100644 --- a/include/linux/mux/consumer.h +++ b/include/linux/mux/consumer.h @@ -15,6 +15,7 @@ struct device; struct mux_control; struct mux_state; +struct mux_state_array; =20 unsigned int mux_control_states(struct mux_control *mux); int __must_check mux_control_select_delay(struct mux_control *mux, @@ -39,6 +40,8 @@ static inline int __must_check mux_state_select(struct mu= x_state *mstate) return mux_state_select_delay(mstate, 0); } =20 +int mux_state_array_select(struct mux_state_array *mstates); + static inline int __must_check mux_control_try_select(struct mux_control *= mux, unsigned int state) { @@ -53,6 +56,8 @@ static inline int __must_check mux_state_try_select(struc= t mux_state *mstate) int mux_control_deselect(struct mux_control *mux); int mux_state_deselect(struct mux_state *mstate); =20 +int mux_state_array_deselect(struct mux_state_array *mstates); + struct mux_control *mux_control_get(struct device *dev, const char *mux_na= me); void mux_control_put(struct mux_control *mux); =20 @@ -61,4 +66,6 @@ struct mux_control *devm_mux_control_get(struct device *d= ev, struct mux_state *devm_mux_state_get(struct device *dev, const char *mux_name); =20 +struct mux_state_array *devm_mux_state_array_get(struct device *dev); + #endif /* _LINUX_MUX_CONSUMER_H */ --=20 2.42.0.rc1.204.g551eb34607-goog From nobody Tue Dec 16 23:46:37 2025 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 04CC1C3DA6F for ; Thu, 24 Aug 2023 12:19:11 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S241339AbjHXMSl (ORCPT ); Thu, 24 Aug 2023 08:18:41 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:56854 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S241327AbjHXMSM (ORCPT ); Thu, 24 Aug 2023 08:18:12 -0400 Received: from mail-yw1-x1149.google.com (mail-yw1-x1149.google.com [IPv6:2607:f8b0:4864:20::1149]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id A10D9170F for ; Thu, 24 Aug 2023 05:18:10 -0700 (PDT) Received: by mail-yw1-x1149.google.com with SMTP id 00721157ae682-5925fb6087bso18323537b3.2 for ; Thu, 24 Aug 2023 05:18:10 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20221208; t=1692879490; x=1693484290; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=8p4eP1h14QFMqmWjHAlDpl9k137Tq9L6HI1RUlUFcRU=; b=bAe+LE47owmSvY4yrd1nhijVG3xqAl4ofPuwuyuSsz+sa90SwcXv5VlvGcsn7obLJi DmvcBWk9fg23EM3JnDwQXoHRlyr9sluQI5XMhy9gNI6ZzoaTTlq63XFNM0UeSgIWNDH9 stb2f2hKT0guOgKSanGzIZyiymFz+L6GT6jJN0yZnJXQOoiBUo1vwkcdrZe1lF04q4Yt KnirdG4q72l/h5vMcTpau/bHEynbkZbXtI6nf/rr3eKs8IhTl5CwCvDXmtm+P5m1JTey eDXNOBQfz8ahbtT9VkwGnbUPyGP823wo04s9D+H11eguDAnMJGpiZqIxK33rwcljoc0e RFsA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1692879490; x=1693484290; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=8p4eP1h14QFMqmWjHAlDpl9k137Tq9L6HI1RUlUFcRU=; b=EHW89Ja6zh2RAfPNK0fzoTuvZ+Agv7QTR/FXT9/CbUWiAe2U1e0V/4nhSicjgmiAs2 M1HXwAz0P6tADysblha2V7oNZTLVbPq00uG2ETw2sARVo3bYuQzRxYlSxpiOy1iXPSTB rYRj1iHoW6Sqaq8w80c+rMru33yF7wbyj2Mx3g3TDwOQHWfZ7xzT8gfr3BuYvvfV7nBb HbE7yFSBkFtQnfjYNxXq0uGLFobMuNyf4ZTgyFB7/ZvqqWvptsgwgY3jUUkw3ViKBotE 6K93RQtRkE+jP9fZig4jar7eAywZpNTGAD3jOSArniPlh4J0HGff4/TGRjVXrvlI5hXD 5N5Q== X-Gm-Message-State: AOJu0YzypMZDFggY3mnzbZx81RFS7sVCebYnLsmQeFE/L8S1NrrB3o96 TNu2uixfHnTsQR9Hh0pfWgD+JUt9y/h42N1ULM0= X-Google-Smtp-Source: AGHT+IGKgWqctfFTT+x7LlxxuuSo9bGGRF1PasrpOpaIVfxKr+wreeVqCWz0GZVTWjlWdozejvRBzcQptBHyhPLCOKc= X-Received: from anikett.c.googlers.com ([fda3:e722:ac3:cc00:4f:4b78:c0a8:2551]) (user=aniketmaurya job=sendgmr) by 2002:a81:af59:0:b0:56d:1b6:5360 with SMTP id x25-20020a81af59000000b0056d01b65360mr255962ywj.5.1692879489980; Thu, 24 Aug 2023 05:18:09 -0700 (PDT) Date: Thu, 24 Aug 2023 12:17:50 +0000 In-Reply-To: <20230824121750.1673566-1-aniketmaurya@google.com> Mime-Version: 1.0 References: <20230824121750.1673566-1-aniketmaurya@google.com> X-Mailer: git-send-email 2.42.0.rc1.204.g551eb34607-goog Message-ID: <20230824121750.1673566-3-aniketmaurya@google.com> Subject: [PATCH v1 2/2] mux: Introduce optional variant of consumer APIs From: Aniket To: Peter Rosin Cc: linux-kernel@vger.kernel.org, joychakr@google.com, Aniket Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Add optional variant of get APIs for mux-control, mux-state and mux-state-array. These APIs allow client drivers to not fail in case mux is not present on the platform. Signed-off-by: Aniket --- drivers/mux/core.c | 24 ++++++++++++++++++++++++ include/linux/mux/consumer.h | 22 ++++++++++++++++++++++ 2 files changed, 46 insertions(+) diff --git a/drivers/mux/core.c b/drivers/mux/core.c index e4e57847e904..a6772f23ef6e 100644 --- a/drivers/mux/core.c +++ b/drivers/mux/core.c @@ -379,6 +379,9 @@ int mux_control_select_delay(struct mux_control *mux, u= nsigned int state, { int ret; =20 + if (!mux) + return 0; + ret =3D down_killable(&mux->lock); if (ret < 0) return ret; @@ -414,6 +417,9 @@ EXPORT_SYMBOL_GPL(mux_control_select_delay); */ int mux_state_select_delay(struct mux_state *mstate, unsigned int delay_us) { + if (!mstate) + return 0; + return mux_control_select_delay(mstate->mux, mstate->state, delay_us); } EXPORT_SYMBOL_GPL(mux_state_select_delay); @@ -440,6 +446,9 @@ int mux_state_array_select(struct mux_state_array *msta= tes) { int ret, i; =20 + if (!mstates) + return 0; + for (i =3D 0; i < mstates->num; ++i) { ret =3D mux_state_select(mstates->mstate[i]); if (ret < 0) @@ -477,6 +486,9 @@ int mux_control_try_select_delay(struct mux_control *mu= x, unsigned int state, { int ret; =20 + if (!mux) + return 0; + if (down_trylock(&mux->lock)) return -EBUSY; =20 @@ -508,6 +520,9 @@ EXPORT_SYMBOL_GPL(mux_control_try_select_delay); */ int mux_state_try_select_delay(struct mux_state *mstate, unsigned int dela= y_us) { + if (!mstate) + return 0; + return mux_control_try_select_delay(mstate->mux, mstate->state, delay_us); } EXPORT_SYMBOL_GPL(mux_state_try_select_delay); @@ -528,6 +543,9 @@ int mux_control_deselect(struct mux_control *mux) { int ret =3D 0; =20 + if (!mux) + return 0; + if (mux->idle_state !=3D MUX_IDLE_AS_IS && mux->idle_state !=3D mux->cached_state) ret =3D mux_control_set(mux, mux->idle_state); @@ -552,6 +570,9 @@ EXPORT_SYMBOL_GPL(mux_control_deselect); */ int mux_state_deselect(struct mux_state *mstate) { + if (!mstate) + return 0; + return mux_control_deselect(mstate->mux); } EXPORT_SYMBOL_GPL(mux_state_deselect); @@ -569,6 +590,9 @@ int mux_state_array_deselect(struct mux_state_array *ms= tates) { int ret, i; =20 + if (!mstates) + return 0; + for (i =3D 0; i < mstates->num; ++i) { ret =3D mux_state_deselect(mstates->mstate[i]); if (ret < 0) diff --git a/include/linux/mux/consumer.h b/include/linux/mux/consumer.h index da15d0542008..397b1c5848c7 100644 --- a/include/linux/mux/consumer.h +++ b/include/linux/mux/consumer.h @@ -63,9 +63,31 @@ void mux_control_put(struct mux_control *mux); =20 struct mux_control *devm_mux_control_get(struct device *dev, const char *mux_name); +static inline struct mux_control * +devm_mux_control_get_optional(struct device *dev, const char *mux_name) +{ + struct mux_control *mux =3D devm_mux_control_get(dev, mux_name); + + return (PTR_ERR(mux) =3D=3D -ENOENT) ? NULL : mux; +} + struct mux_state *devm_mux_state_get(struct device *dev, const char *mux_name); +static inline struct mux_state * +devm_mux_state_get_optional(struct device *dev, const char *mux_name) +{ + struct mux_state *mstate =3D devm_mux_state_get(dev, mux_name); + + return (PTR_ERR(mstate) =3D=3D -ENOENT) ? NULL : mstate; +} =20 struct mux_state_array *devm_mux_state_array_get(struct device *dev); +static inline struct mux_state_array * +devm_mux_state_array_get_optional(struct device *dev) +{ + struct mux_state_array *mstates =3D devm_mux_state_array_get(dev); + + return (PTR_ERR(mstates) =3D=3D -ENOENT) ? NULL : mstates; +} =20 #endif /* _LINUX_MUX_CONSUMER_H */ --=20 2.42.0.rc1.204.g551eb34607-goog