1 files changed, 66 insertions, 27 deletions

diff --git a/drivers/base/firmware_class.c b/drivers/base/firmware_class.c
index eb8fb94ae2c5..8a97ddfa6122 100644
--- a/drivers/base/firmware_class.c
+++ b/drivers/base/firmware_class.c
@@ -96,6 +96,15 @@ static inline long firmware_loading_timeout(void)
         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)
+#ifdef CONFIG_FW_LOADER_USER_HELPER
+#define FW_OPT_FALLBACK (1U << 2)
+#else
+#define FW_OPT_FALLBACK 0
+#endif
+
 struct firmware_cache {
         /* firmware_buf instance will be added into the below list */
         spinlock_t lock;
@@ -219,6 +228,7 @@ static int fw_lookup_and_allocate_buf(const char *fw_name,
 }
 
 static void __fw_free_buf(struct kref *ref)
+        __releases(&fwc->lock)
 {
         struct firmware_buf *buf = to_fwbuf(ref);
         struct firmware_cache *fwc = buf->fwc;
@@ -270,21 +280,21 @@ module_param_string(path, fw_path_para, sizeof(fw_path_para), 0644);
 MODULE_PARM_DESC(path, "customized firmware image search path with a higher priority than default path");
 
 /* Don't inline this: 'struct kstat' is biggish */
-static noinline_for_stack long fw_file_size(struct file *file)
+static noinline_for_stack int fw_file_size(struct file *file)
 {
         struct kstat st;
         if (vfs_getattr(&file->f_path, &st))
                 return -1;
         if (!S_ISREG(st.mode))
                 return -1;
-        if (st.size != (long)st.size)
+        if (st.size != (int)st.size)
                 return -1;
         return st.size;
 }
 
 static int fw_read_file_contents(struct file *file, struct firmware_buf *fw_buf)
 {
-        long size;
+        int size;
         char *buf;
         int rc;
 
@@ -820,7 +830,7 @@ static void firmware_class_timeout_work(struct work_struct *work)
 
 static struct firmware_priv *
 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 device *f_dev;
@@ -832,7 +842,7 @@ fw_create_instance(struct firmware *firmware, const char *fw_name,
                 goto exit;
         }
 
-        fw_priv->nowait = nowait;
+        fw_priv->nowait = !!(opt_flags & FW_OPT_NOWAIT);
         fw_priv->fw = firmware;
         INIT_DELAYED_WORK(&fw_priv->timeout_work,
                 firmware_class_timeout_work);
@@ -848,8 +858,8 @@ exit:
 }
 
 /* load a firmware via user helper */
-static int _request_firmware_load(struct firmware_priv *fw_priv, bool uevent,
-                                  long timeout)
+static int _request_firmware_load(struct firmware_priv *fw_priv,
+                                  unsigned int opt_flags, long timeout)
 {
         int retval = 0;
         struct device *f_dev = &fw_priv->dev;
@@ -885,7 +895,7 @@ static int _request_firmware_load(struct firmware_priv *fw_priv, bool uevent,
                 goto err_del_bin_attr;
         }
 
-        if (uevent) {
+        if (opt_flags & FW_OPT_UEVENT) {
                 buf->need_uevent = true;
                 dev_set_uevent_suppress(f_dev, false);
                 dev_dbg(f_dev, "firmware: requesting %s\n", buf->fw_id);
@@ -911,16 +921,16 @@ err_put_dev:
 
 static int fw_load_from_user_helper(struct firmware *firmware,
                                     const char *name, struct device *device,
-                                    bool uevent, bool nowait, long timeout)
+                                    unsigned int opt_flags, long timeout)
 {
         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))
                 return PTR_ERR(fw_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
@@ -942,7 +952,7 @@ static void kill_requests_without_uevent(void)
 #else /* CONFIG_FW_LOADER_USER_HELPER */
 static inline int
 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)
 {
         return -ENOENT;
@@ -1023,7 +1033,7 @@ _request_firmware_prepare(struct firmware **firmware_p, const char *name,
 }
 
 static int assign_firmware_buf(struct firmware *fw, struct device *device,
-                                bool skip_cache)
+                               unsigned int opt_flags)
 {
         struct firmware_buf *buf = fw->priv;
 
@@ -1040,7 +1050,8 @@ static int assign_firmware_buf(struct firmware *fw, struct device *device,
          * device may has been deleted already, but the problem
          * 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);
 
         /*
@@ -1061,7 +1072,7 @@ static int assign_firmware_buf(struct firmware *fw, struct device *device,
 /* called from request_firmware() and request_firmware_work_func() */
 static int
 _request_firmware(const struct firmware **firmware_p, const char *name,
-                  struct device *device, bool uevent, bool nowait)
+                  struct device *device, unsigned int opt_flags)
 {
         struct firmware *fw;
         long timeout;
@@ -1076,7 +1087,7 @@ _request_firmware(const struct firmware **firmware_p, const char *name,
 
         ret = 0;
         timeout = firmware_loading_timeout();
-        if (nowait) {
+        if (opt_flags & FW_OPT_NOWAIT) {
                 timeout = usermodehelper_read_lock_wait(timeout);
                 if (!timeout) {
                         dev_dbg(device, "firmware: %s loading timed out\n",
@@ -1095,16 +1106,18 @@ _request_firmware(const struct firmware **firmware_p, const char *name,
 
         ret = fw_get_filesystem_firmware(device, fw->priv);
         if (ret) {
-                dev_warn(device, "Direct firmware load failed with error %d\n",
-                         ret);
-                dev_warn(device, "Falling back to user helper\n");
-                ret = fw_load_from_user_helper(fw, name, device,
-                                               uevent, nowait, timeout);
+                if (opt_flags & FW_OPT_FALLBACK) {
+                        dev_warn(device,
+                                 "Direct firmware load failed with error %d\n",
+                                 ret);
+                        dev_warn(device, "Falling back to user helper\n");
+                        ret = fw_load_from_user_helper(fw, name, device,
+                                                       opt_flags, timeout);
+                }
         }
 
-        /* don't cache firmware handled without uevent */
         if (!ret)
-                ret = assign_firmware_buf(fw, device, !uevent);
+                ret = assign_firmware_buf(fw, device, opt_flags);
 
         usermodehelper_read_unlock();
 
@@ -1146,12 +1159,37 @@ request_firmware(const struct firmware **firmware_p, const char *name,
 
         /* Need to pin this module until return */
         __module_get(THIS_MODULE);
-        ret = _request_firmware(firmware_p, name, device, true, false);
+        ret = _request_firmware(firmware_p, name, device,
+                                FW_OPT_UEVENT | FW_OPT_FALLBACK);
         module_put(THIS_MODULE);
         return ret;
 }
 EXPORT_SYMBOL(request_firmware);
 
+#ifdef CONFIG_FW_LOADER_USER_HELPER
+/**
+ * request_firmware: - load firmware directly without usermode helper
+ * @firmware_p: pointer to firmware image
+ * @name: name of firmware file
+ * @device: device for which firmware is being loaded
+ *
+ * This function works pretty much like request_firmware(), but this doesn't
+ * fall back to usermode helper even if the firmware couldn't be loaded
+ * directly from fs.  Hence it's useful for loading optional firmwares, which
+ * aren't always present, without extra long timeouts of udev.
+ **/
+int request_firmware_direct(const struct firmware **firmware_p,
+                            const char *name, struct device *device)
+{
+        int ret;
+        __module_get(THIS_MODULE);
+        ret = _request_firmware(firmware_p, name, device, FW_OPT_UEVENT);
+        module_put(THIS_MODULE);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(request_firmware_direct);
+#endif
+
 /**
  * release_firmware: - release the resource associated with a firmware image
  * @fw: firmware resource to release
@@ -1174,7 +1212,7 @@ struct firmware_work {
         struct device *device;
         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)
@@ -1185,7 +1223,7 @@ static void request_firmware_work_func(struct work_struct *work)
         fw_work = container_of(work, struct firmware_work, work);
 
         _request_firmware(&fw, fw_work->name, fw_work->device,
-                          fw_work->uevent, true);
+                          fw_work->opt_flags);
         fw_work->cont(fw, fw_work->context);
         put_device(fw_work->device); /* taken in request_firmware_nowait() */
 
@@ -1233,7 +1271,8 @@ request_firmware_nowait(
         fw_work->device = device;
         fw_work->context = context;
         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)) {
                 kfree(fw_work);