drivers/net/wireless/marvell/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         if (priv->helper_fw) {
  57                 release_firmware (priv->helper_fw);
  58                 priv->helper_fw = NULL;
  59         }
  60         release_firmware (firmware);
  61 }
  62
  63 static void helper_firmware_cb(const struct firmware *firmware, void *context)
  64 {
  65         struct lbs_private *priv = context;
  66
  67         if (!firmware) {
  68                 /* Failed to find firmware: try next table entry */
  69                 load_next_firmware_from_table(priv);
  70                 return;
  71         }
  72
  73         /* Firmware found! */
  74         if (priv->fw_iter->fwname) {
  75                 priv->helper_fw = firmware;
  76                 do_load_firmware(priv, priv->fw_iter->fwname, main_firmware_cb);
  77         } else {
  78                 /* No main firmware needed for this helper --> success! */
  79                 lbs_fw_loaded(priv, 0, firmware, NULL);
  80         }
  81 }
  82
  83 static void load_next_firmware_from_table(struct lbs_private *priv)
  84 {
  85         const struct lbs_fw_table *iter;
  86
  87         if (!priv->fw_iter)
  88                 iter = priv->fw_table;
  89         else
  90                 iter = ++priv->fw_iter;
  91
  92         if (priv->helper_fw) {
  93                 release_firmware(priv->helper_fw);
  94                 priv->helper_fw = NULL;
  95         }
  96
  97 next:
  98         if (!iter->helper) {
  99                 /* End of table hit. */
 100                 lbs_fw_loaded(priv, -ENOENT, NULL, NULL);
 101                 return;
 102         }
 103
 104         if (iter->model != priv->fw_model) {
 105                 iter++;
 106                 goto next;
 107         }
 108
 109         priv->fw_iter = iter;
 110         do_load_firmware(priv, iter->helper, helper_firmware_cb);
 111 }
 112
 113 void lbs_wait_for_firmware_load(struct lbs_private *priv)
 114 {
 115         wait_event(priv->fw_waitq, priv->fw_callback == NULL);
 116 }
 117
 118 /**
 119  *  lbs_get_firmware_async - Retrieves firmware asynchronously. Can load
 120  *  either a helper firmware and a main firmware (2-stage), or just the helper.
 121  *
 122  *  @priv:      Pointer to lbs_private instance
 123  *  @dev:       A pointer to &device structure
 124  *  @card_model: Bus-specific card model ID used to filter firmware table
 125  *              elements
 126  *  @fw_table:  Table of firmware file names and device model numbers
 127  *              terminated by an entry with a NULL helper name
 128  *      @callback: User callback to invoke when firmware load succeeds or fails.
 129  */
 130 int lbs_get_firmware_async(struct lbs_private *priv, struct device *device,
 131                             u32 card_model, const struct lbs_fw_table *fw_table,
 132                             lbs_fw_cb callback)
 133 {
 134         unsigned long flags;
 135
 136         spin_lock_irqsave(&priv->driver_lock, flags);
 137         if (priv->fw_callback) {
 138                 lbs_deb_fw("firmware load already in progress\n");
 139                 spin_unlock_irqrestore(&priv->driver_lock, flags);
 140                 return -EBUSY;
 141         }
 142
 143         priv->fw_device = device;
 144         priv->fw_callback = callback;
 145         priv->fw_table = fw_table;
 146         priv->fw_iter = NULL;
 147         priv->fw_model = card_model;
 148         spin_unlock_irqrestore(&priv->driver_lock, flags);
 149
 150         lbs_deb_fw("Starting async firmware load\n");
 151         load_next_firmware_from_table(priv);
 152         return 0;
 153 }
 154 EXPORT_SYMBOL_GPL(lbs_get_firmware_async);
 155
 156 /**
 157  *  lbs_get_firmware - Retrieves two-stage firmware
 158  *
 159  *  @dev:       A pointer to &device structure
 160  *  @card_model: Bus-specific card model ID used to filter firmware table
 161  *              elements
 162  *  @fw_table:  Table of firmware file names and device model numbers
 163  *              terminated by an entry with a NULL helper name
 164  *  @helper:    On success, the helper firmware; caller must free
 165  *  @mainfw:    On success, the main firmware; caller must free
 166  *
 167  * Deprecated: use lbs_get_firmware_async() instead.
 168  *
 169  *  returns:            0 on success, non-zero on failure
 170  */
 171 int lbs_get_firmware(struct device *dev, u32 card_model,
 172                         const struct lbs_fw_table *fw_table,
 173                         const struct firmware **helper,
 174                         const struct firmware **mainfw)
 175 {
 176         const struct lbs_fw_table *iter;
 177         int ret;
 178
 179         BUG_ON(helper == NULL);
 180         BUG_ON(mainfw == NULL);
 181
 182         /* Search for firmware to use from the table. */
 183         iter = fw_table;
 184         while (iter && iter->helper) {
 185                 if (iter->model != card_model)
 186                         goto next;
 187
 188                 if (*helper == NULL) {
 189                         ret = request_firmware(helper, iter->helper, dev);
 190                         if (ret)
 191                                 goto next;
 192
 193                         /* If the device has one-stage firmware (ie cf8305) and
 194                          * we've got it then we don't need to bother with the
 195                          * main firmware.
 196                          */
 197                         if (iter->fwname == NULL)
 198                                 return 0;
 199                 }
 200
 201                 if (*mainfw == NULL) {
 202                         ret = request_firmware(mainfw, iter->fwname, dev);
 203                         if (ret) {
 204                                 /* Clear the helper to ensure we don't have
 205                                  * mismatched firmware pairs.
 206                                  */
 207                                 release_firmware(*helper);
 208                                 *helper = NULL;
 209                         }
 210                 }
 211
 212                 if (*helper && *mainfw)
 213                         return 0;
 214
 215   next:
 216                 iter++;
 217         }
 218
 219         /* Failed */
 220         release_firmware(*helper);
 221         *helper = NULL;
 222         release_firmware(*mainfw);
 223         *mainfw = NULL;
 224
 225         return -ENOENT;
 226 }
 227 EXPORT_SYMBOL_GPL(lbs_get_firmware);