korg/linux
0
0
Fork 0
mirror of https://mirrors.bfsu.edu.cn/git/linux.git synced 2024-11-15 08:14:15 +08:00
Code Issues Packages Projects Releases Wiki Activity

firmware: Use bit flags instead of boolean combos

Browse Source 
More than two boolean arguments to a function are rather confusing and
error-prone for callers.  Let's make the behavior bit flags instead of
triple combos.

A nice suggestion by Borislav Petkov.

Acked-by: Borislav Petkov <bp@suse.de>
Acked-by: Prarit Bhargava <prarit@redhat.com>
Acked-by: Ming Lei <ming.lei@canonical.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
Takashi Iwai 2013-12-02 15:38:18 +01:00 committed by Greg Kroah-Hartman
parent 75da02b29f
commit 14c4bae77c
1 changed files with 29 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
drivers/base/firmware_class.c
View File

@ -96,6 +96,11 @@ static inline long firmware_loading_timeout(void)
return loading_timeout > 0 ? loading_timeout * HZ : MAX_SCHEDULE_TIMEOUT; return loading_timeout > 0 ? loading_timeout * HZ : MAX_SCHEDULE_TIMEOUT;
} }
/* firmware behavior options */
#define FW_OPT_UEVENT (1U << 0)
#define FW_OPT_NOWAIT (1U << 1)
#define FW_OPT_FALLBACK (1U << 2)
struct firmware_cache { struct firmware_cache {
/* firmware_buf instance will be added into the below list */ /* firmware_buf instance will be added into the below list */
spinlock_t lock; spinlock_t lock;
@ -820,7 +825,7 @@ static void firmware_class_timeout_work(struct work_struct *work)
static struct firmware_priv * static struct firmware_priv *
fw_create_instance(struct firmware *firmware, const char *fw_name, fw_create_instance(struct firmware *firmware, const char *fw_name,
struct device *device, bool uevent, bool nowait) struct device *device, unsigned int opt_flags)
{ {
struct firmware_priv *fw_priv; struct firmware_priv *fw_priv;
struct device *f_dev; struct device *f_dev;
@ -832,7 +837,7 @@ fw_create_instance(struct firmware *firmware, const char *fw_name,
goto exit; goto exit;
} }
fw_priv->nowait = nowait; fw_priv->nowait = !!(opt_flags & FW_OPT_NOWAIT);
fw_priv->fw = firmware; fw_priv->fw = firmware;
INIT_DELAYED_WORK(&fw_priv->timeout_work, INIT_DELAYED_WORK(&fw_priv->timeout_work,
firmware_class_timeout_work); firmware_class_timeout_work);
@ -848,8 +853,8 @@ exit:
} }
/* load a firmware via user helper */ /* load a firmware via user helper */
static int _request_firmware_load(struct firmware_priv *fw_priv, bool uevent, static int _request_firmware_load(struct firmware_priv *fw_priv,
long timeout) unsigned int opt_flags, long timeout)
{ {
int retval = 0; int retval = 0;
struct device *f_dev = &fw_priv->dev; struct device *f_dev = &fw_priv->dev;
@ -885,7 +890,7 @@ static int _request_firmware_load(struct firmware_priv *fw_priv, bool uevent,
goto err_del_bin_attr; goto err_del_bin_attr;
} }
if (uevent) { if (opt_flags & FW_OPT_UEVENT) {
buf->need_uevent = true; buf->need_uevent = true;
dev_set_uevent_suppress(f_dev, false); dev_set_uevent_suppress(f_dev, false);
dev_dbg(f_dev, "firmware: requesting %s\n", buf->fw_id); dev_dbg(f_dev, "firmware: requesting %s\n", buf->fw_id);
@ -911,16 +916,16 @@ err_put_dev:
static int fw_load_from_user_helper(struct firmware *firmware, static int fw_load_from_user_helper(struct firmware *firmware,
const char *name, struct device *device, const char *name, struct device *device,
bool uevent, bool nowait, long timeout) unsigned int opt_flags, long timeout)
{ {
struct firmware_priv *fw_priv; struct firmware_priv *fw_priv;
fw_priv = fw_create_instance(firmware, name, device, uevent, nowait); fw_priv = fw_create_instance(firmware, name, device, opt_flags);
if (IS_ERR(fw_priv)) if (IS_ERR(fw_priv))
return PTR_ERR(fw_priv); return PTR_ERR(fw_priv);
fw_priv->buf = firmware->priv; fw_priv->buf = firmware->priv;
return _request_firmware_load(fw_priv, uevent, timeout); return _request_firmware_load(fw_priv, opt_flags, timeout);
} }
#ifdef CONFIG_PM_SLEEP #ifdef CONFIG_PM_SLEEP
@ -942,7 +947,7 @@ static void kill_requests_without_uevent(void)
#else /* CONFIG_FW_LOADER_USER_HELPER */ #else /* CONFIG_FW_LOADER_USER_HELPER */
static inline int static inline int
fw_load_from_user_helper(struct firmware *firmware, const char *name, fw_load_from_user_helper(struct firmware *firmware, const char *name,
struct device *device, bool uevent, bool nowait, struct device *device, unsigned int opt_flags,
long timeout) long timeout)
{ {
return -ENOENT; return -ENOENT;
@ -1023,7 +1028,7 @@ _request_firmware_prepare(struct firmware **firmware_p, const char *name,
} }
static int assign_firmware_buf(struct firmware *fw, struct device *device, static int assign_firmware_buf(struct firmware *fw, struct device *device,
bool skip_cache) unsigned int opt_flags)
{ {
struct firmware_buf *buf = fw->priv; struct firmware_buf *buf = fw->priv;
@ -1040,7 +1045,8 @@ static int assign_firmware_buf(struct firmware *fw, struct device *device,
* device may has been deleted already, but the problem * device may has been deleted already, but the problem
* should be fixed in devres or driver core. * should be fixed in devres or driver core.
*/ */
if (device && !skip_cache) /* don't cache firmware handled without uevent */
if (device && (opt_flags & FW_OPT_UEVENT))
fw_add_devm_name(device, buf->fw_id); fw_add_devm_name(device, buf->fw_id);
/* /*
@ -1061,7 +1067,7 @@ static int assign_firmware_buf(struct firmware *fw, struct device *device,
/* called from request_firmware() and request_firmware_work_func() */ /* called from request_firmware() and request_firmware_work_func() */
static int static int
_request_firmware(const struct firmware **firmware_p, const char *name, _request_firmware(const struct firmware **firmware_p, const char *name,
struct device *device, bool uevent, bool nowait, bool fallback) struct device *device, unsigned int opt_flags)
{ {
struct firmware *fw; struct firmware *fw;
long timeout; long timeout;
@ -1076,7 +1082,7 @@ _request_firmware(const struct firmware **firmware_p, const char *name,
ret = 0; ret = 0;
timeout = firmware_loading_timeout(); timeout = firmware_loading_timeout();
if (nowait) { if (opt_flags & FW_OPT_NOWAIT) {
timeout = usermodehelper_read_lock_wait(timeout); timeout = usermodehelper_read_lock_wait(timeout);
if (!timeout) { if (!timeout) {
dev_dbg(device, "firmware: %s loading timed out\n", dev_dbg(device, "firmware: %s loading timed out\n",
@ -1095,19 +1101,18 @@ _request_firmware(const struct firmware **firmware_p, const char *name,
ret = fw_get_filesystem_firmware(device, fw->priv); ret = fw_get_filesystem_firmware(device, fw->priv);
if (ret) { if (ret) {
if (fallback) { if (opt_flags & FW_OPT_FALLBACK) {
dev_warn(device, dev_warn(device,
"Direct firmware load failed with error %d\n", "Direct firmware load failed with error %d\n",
ret); ret);
dev_warn(device, "Falling back to user helper\n"); dev_warn(device, "Falling back to user helper\n");
ret = fw_load_from_user_helper(fw, name, device, ret = fw_load_from_user_helper(fw, name, device,
uevent, nowait, timeout); opt_flags, timeout);
} }
} }
/* don't cache firmware handled without uevent */
if (!ret) if (!ret)
ret = assign_firmware_buf(fw, device, !uevent); ret = assign_firmware_buf(fw, device, opt_flags);
usermodehelper_read_unlock(); usermodehelper_read_unlock();
@ -1149,7 +1154,8 @@ request_firmware(const struct firmware **firmware_p, const char *name,
/* Need to pin this module until return */ /* Need to pin this module until return */
__module_get(THIS_MODULE); __module_get(THIS_MODULE);
ret = _request_firmware(firmware_p, name, device, true, false, true); ret = _request_firmware(firmware_p, name, device,
FW_OPT_UEVENT | FW_OPT_FALLBACK);
module_put(THIS_MODULE); module_put(THIS_MODULE);
return ret; return ret;
} }
@ -1172,7 +1178,7 @@ int request_firmware_direct(const struct firmware **firmware_p,
{ {
int ret; int ret;
__module_get(THIS_MODULE); __module_get(THIS_MODULE);
ret = _request_firmware(firmware_p, name, device, true, false, false); ret = _request_firmware(firmware_p, name, device, FW_OPT_UEVENT);
module_put(THIS_MODULE); module_put(THIS_MODULE);
return ret; return ret;
} }
@ -1201,7 +1207,7 @@ struct firmware_work {
struct device *device; struct device *device;
void *context; void *context;
void (*cont)(const struct firmware *fw, void *context); void (*cont)(const struct firmware *fw, void *context);
bool uevent; unsigned int opt_flags;
}; };
static void request_firmware_work_func(struct work_struct *work) static void request_firmware_work_func(struct work_struct *work)
@ -1212,7 +1218,7 @@ static void request_firmware_work_func(struct work_struct *work)
fw_work = container_of(work, struct firmware_work, work); fw_work = container_of(work, struct firmware_work, work);
_request_firmware(&fw, fw_work->name, fw_work->device, _request_firmware(&fw, fw_work->name, fw_work->device,
fw_work->uevent, true, true); fw_work->opt_flags);
fw_work->cont(fw, fw_work->context); fw_work->cont(fw, fw_work->context);
put_device(fw_work->device); /* taken in request_firmware_nowait() */ put_device(fw_work->device); /* taken in request_firmware_nowait() */
@ -1260,7 +1266,8 @@ request_firmware_nowait(
fw_work->device = device; fw_work->device = device;
fw_work->context = context; fw_work->context = context;
fw_work->cont = cont; fw_work->cont = cont;
fw_work->uevent = uevent; fw_work->opt_flags = FW_OPT_NOWAIT | FW_OPT_FALLBACK |
(uevent ? FW_OPT_UEVENT : 0);
if (!try_module_get(module)) { if (!try_module_get(module)) {
kfree(fw_work); kfree(fw_work);