drivers/net/wireless/libertas/firmware.c

   1 /*
   2  * Firmware loading and handling functions.
   3  */
   4
   5 #include <linux/sched.h>
   6 #include <linux/firmware.h>
   7 #include <linux/module.h>
   8
   9 #include "dev.h"
  10 #include "decl.h"
  11
  12 static void load_next_firmware_from_table(struct lbs_private *private);
  13
  14 static void lbs_fw_loaded(struct lbs_private *priv, int ret,
  15         const struct firmware *helper, const struct firmware *mainfw)
  16 {
  17         unsigned long flags;
  18
  19         lbs_deb_fw("firmware load complete, code %d\n", ret);
  20
  21         /* User must free helper/mainfw */
  22         priv->fw_callback(priv, ret, helper, mainfw);
  23
  24         spin_lock_irqsave(&priv->driver_lock, flags);
  25         priv->fw_callback = NULL;
  26         wake_up(&priv->fw_waitq);
  27         spin_unlock_irqrestore(&priv->driver_lock, flags);
  28 }
  29
  30 static void do_load_firmware(struct lbs_private *priv, const char *name,
  31         void (*cb)(const struct firmware *fw, void *context))
  32 {
  33         int ret;
  34
  35         lbs_deb_fw("Requesting %s\n", name);
  36         ret = request_firmware_nowait(THIS_MODULE, true, name,
  37                         priv->fw_device, GFP_KERNEL, priv, cb);
  38         if (ret) {
  39                 lbs_deb_fw("request_firmware_nowait error %d\n", ret);
  40                 lbs_fw_loaded(priv, ret, NULL, NULL);
  41         }
  42 }
  43
  44 static void main_firmware_cb(const struct firmware *firmware, void *context)
  45 {
  46         struct lbs_private *priv = context;
  47
  48         if (!firmware) {
  49                 /* Failed to find firmware: try next table entry */
  50                 load_next_firmware_from_table(priv);
  51                 return;
  52         }
  53
  54         /* Firmware found! */
  55         lbs_fw_loaded(priv, 0, priv->helper_fw, firmware);
  56 }
  57
  58 static void helper_firmware_cb(const struct firmware *firmware, void *context)
  59 {
  60         struct lbs_private *priv = context;
  61
  62         if (!firmware) {
  63                 /* Failed to find firmware: try next table entry */
  64                 load_next_firmware_from_table(priv);
  65                 return;
  66         }
  67
  68         /* Firmware found! */
  69         if (priv->fw_iter->fwname) {
  70                 priv->helper_fw = firmware;
  71                 do_load_firmware(priv, priv->fw_iter->fwname, main_firmware_cb);
  72         } else {
  73                 /* No main firmware needed for this helper --> success! */
  74                 lbs_fw_loaded(priv, 0, firmware, NULL);
  75         }
  76 }
  77
  78 static void load_next_firmware_from_table(struct lbs_private *priv)
  79 {
  80         const struct lbs_fw_table *iter;
  81
  82         if (!priv->fw_iter)
  83                 iter = priv->fw_table;
  84         else
  85                 iter = ++priv->fw_iter;
  86
  87         if (priv->helper_fw) {
  88                 release_firmware(priv->helper_fw);
  89                 priv->helper_fw = NULL;
  90         }
  91
  92 next:
  93         if (!iter->helper) {
  94                 /* End of table hit. */
  95                 lbs_fw_loaded(priv, -ENOENT, NULL, NULL);
  96                 return;
  97         }
  98
  99         if (iter->model != priv->fw_model) {
 100                 iter++;
 101                 goto next;
 102         }
 103
 104         priv->fw_iter = iter;
 105         do_load_firmware(priv, iter->helper, helper_firmware_cb);
 106 }
 107
 108 void lbs_wait_for_firmware_load(struct lbs_private *priv)
 109 {
 110         wait_event(priv->fw_waitq, priv->fw_callback == NULL);
 111 }
 112
 113 /**
 114  *  lbs_get_firmware_async - Retrieves firmware asynchronously. Can load
 115  *  either a helper firmware and a main firmware (2-stage), or just the helper.
 116  *
 117  *  @priv:      Pointer to lbs_private instance
 118  *  @dev:       A pointer to &device structure
 119  *  @card_model: Bus-specific card model ID used to filter firmware table
 120  *              elements
 121  *  @fw_table:  Table of firmware file names and device model numbers
 122  *              terminated by an entry with a NULL helper name
 123  *      @callback: User callback to invoke when firmware load succeeds or fails.
 124  */
 125 int lbs_get_firmware_async(struct lbs_private *priv, struct device *device,
 126                             u32 card_model, const struct lbs_fw_table *fw_table,
 127                             lbs_fw_cb callback)
 128 {
 129         unsigned long flags;
 130
 131         spin_lock_irqsave(&priv->driver_lock, flags);
 132         if (priv->fw_callback) {
 133                 lbs_deb_fw("firmware load already in progress\n");
 134                 spin_unlock_irqrestore(&priv->driver_lock, flags);
 135                 return -EBUSY;
 136         }
 137
 138         priv->fw_device = device;
 139         priv->fw_callback = callback;
 140         priv->fw_table = fw_table;
 141         priv->fw_iter = NULL;
 142         priv->fw_model = card_model;
 143         spin_unlock_irqrestore(&priv->driver_lock, flags);
 144
 145         lbs_deb_fw("Starting async firmware load\n");
 146         load_next_firmware_from_table(priv);
 147         return 0;
 148 }
 149 EXPORT_SYMBOL_GPL(lbs_get_firmware_async);
 150
 151 /**
 152  *  lbs_get_firmware - Retrieves two-stage firmware
 153  *
 154  *  @dev:       A pointer to &device structure
 155  *  @card_model: Bus-specific card model ID used to filter firmware table
 156  *              elements
 157  *  @fw_table:  Table of firmware file names and device model numbers
 158  *              terminated by an entry with a NULL helper name
 159  *  @helper:    On success, the helper firmware; caller must free
 160  *  @mainfw:    On success, the main firmware; caller must free
 161  *
 162  * Deprecated: use lbs_get_firmware_async() instead.
 163  *
 164  *  returns:            0 on success, non-zero on failure
 165  */
 166 int lbs_get_firmware(struct device *dev, u32 card_model,
 167                         const struct lbs_fw_table *fw_table,
 168                         const struct firmware **helper,
 169                         const struct firmware **mainfw)
 170 {
 171         const struct lbs_fw_table *iter;
 172         int ret;
 173
 174         BUG_ON(helper == NULL);
 175         BUG_ON(mainfw == NULL);
 176
 177         /* Search for firmware to use from the table. */
 178         iter = fw_table;
 179         while (iter && iter->helper) {
 180                 if (iter->model != card_model)
 181                         goto next;
 182
 183                 if (*helper == NULL) {
 184                         ret = request_firmware(helper, iter->helper, dev);
 185                         if (ret)
 186                                 goto next;
 187
 188                         /* If the device has one-stage firmware (ie cf8305) and
 189                          * we've got it then we don't need to bother with the
 190                          * main firmware.
 191                          */
 192                         if (iter->fwname == NULL)
 193                                 return 0;
 194                 }
 195
 196                 if (*mainfw == NULL) {
 197                         ret = request_firmware(mainfw, iter->fwname, dev);
 198                         if (ret) {
 199                                 /* Clear the helper to ensure we don't have
 200                                  * mismatched firmware pairs.
 201                                  */
 202                                 release_firmware(*helper);
 203                                 *helper = NULL;
 204                         }
 205                 }
 206
 207                 if (*helper && *mainfw)
 208                         return 0;
 209
 210   next:
 211                 iter++;
 212         }
 213
 214         /* Failed */
 215         release_firmware(*helper);
 216         *helper = NULL;
 217         release_firmware(*mainfw);
 218         *mainfw = NULL;
 219
 220         return -ENOENT;
 221 }
 222 EXPORT_SYMBOL_GPL(lbs_get_firmware);