drivers/net/wireless/libertas/fw.c

   1 /**
   2   * This file contains the initialization for FW and HW
   3   */
   4 #include <linux/moduleparam.h>
   5 #include <linux/firmware.h>
   6
   7 #include "host.h"
   8 #include "defs.h"
   9 #include "decl.h"
  10 #include "dev.h"
  11 #include "wext.h"
  12 #include "if_usb.h"
  13
  14 char *libertas_fw_name = NULL;
  15 module_param_named(fw_name, libertas_fw_name, charp, 0644);
  16
  17 /**
  18  *  @brief This function checks the validity of Boot2/FW image.
  19  *
  20  *  @param data              pointer to image
  21  *         len               image length
  22  *  @return     0 or -1
  23  */
  24 static int check_fwfile_format(u8 *data, u32 totlen)
  25 {
  26         u8  bincmd, exit;
  27         u32 blksize, offset, len;
  28         int ret;
  29
  30         ret = 1;
  31         exit = len = 0;
  32
  33         do {
  34                 bincmd = *data;
  35                 blksize = *(u32*)(data + offsetof(struct fwheader, datalength));
  36                 switch (bincmd) {
  37                 case FW_HAS_DATA_TO_RECV:
  38                         offset = sizeof(struct fwheader) + blksize;
  39                         data += offset;
  40                         len += offset;
  41                         if (len >= totlen)
  42                                 exit = 1;
  43                         break;
  44                 case FW_HAS_LAST_BLOCK:
  45                         exit = 1;
  46                         ret = 0;
  47                         break;
  48                 default:
  49                         exit = 1;
  50                         break;
  51                 }
  52         } while (!exit);
  53
  54         if (ret)
  55                 lbs_pr_err("firmware file format check FAIL\n");
  56         else
  57                 lbs_deb_fw("firmware file format check PASS\n");
  58
  59         return ret;
  60 }
  61
  62 /**
  63  *  @brief This function downloads firmware image, gets
  64  *  HW spec from firmware and set basic parameters to
  65  *  firmware.
  66  *
  67  *  @param priv    A pointer to wlan_private structure
  68  *  @return        0 or -1
  69  */
  70 static int wlan_setup_station_hw(wlan_private * priv)
  71 {
  72         int ret = -1;
  73         wlan_adapter *adapter = priv->adapter;
  74
  75         lbs_deb_enter(LBS_DEB_FW);
  76
  77         if ((ret = request_firmware(&priv->firmware, libertas_fw_name,
  78                                     priv->hotplug_device)) < 0) {
  79                 lbs_pr_err("request_firmware() failed with %#x\n",
  80                        ret);
  81                 lbs_pr_err("firmware %s not found\n", libertas_fw_name);
  82                 goto done;
  83         }
  84
  85         if(check_fwfile_format(priv->firmware->data, priv->firmware->size)) {
  86                 release_firmware(priv->firmware);
  87                 goto done;
  88         }
  89
  90         ret = priv->hw_prog_firmware(priv);
  91
  92         release_firmware(priv->firmware);
  93
  94         if (ret) {
  95                 lbs_deb_fw("bootloader in invalid state\n");
  96                 ret = -1;
  97                 goto done;
  98         }
  99
 100         /*
 101          * Read MAC address from HW
 102          */
 103         memset(adapter->current_addr, 0xff, ETH_ALEN);
 104
 105         ret = libertas_prepare_and_send_command(priv, cmd_get_hw_spec,
 106                                     0, cmd_option_waitforrsp, 0, NULL);
 107
 108         if (ret) {
 109                 ret = -1;
 110                 goto done;
 111         }
 112
 113         libertas_set_mac_packet_filter(priv);
 114
 115         /* Get the supported Data rates */
 116         ret = libertas_prepare_and_send_command(priv, cmd_802_11_data_rate,
 117                                     cmd_act_get_tx_rate,
 118                                     cmd_option_waitforrsp, 0, NULL);
 119
 120         if (ret) {
 121                 ret = -1;
 122                 goto done;
 123         }
 124
 125         ret = 0;
 126 done:
 127         lbs_deb_leave_args(LBS_DEB_FW, "ret %d", ret);
 128         return ret;
 129 }
 130
 131 static int wlan_allocate_adapter(wlan_private * priv)
 132 {
 133         u32 ulbufsize;
 134         wlan_adapter *adapter = priv->adapter;
 135
 136         struct bss_descriptor *ptempscantable;
 137
 138         /* Allocate buffer to store the BSSID list */
 139         ulbufsize = sizeof(struct bss_descriptor) * MRVDRV_MAX_BSSID_LIST;
 140         if (!(ptempscantable = kzalloc(ulbufsize, GFP_KERNEL))) {
 141                 libertas_free_adapter(priv);
 142                 return -1;
 143         }
 144         adapter->scantable = ptempscantable;
 145
 146         /* Allocate the command buffers */
 147         libertas_allocate_cmd_buffer(priv);
 148
 149         memset(&adapter->libertas_ps_confirm_sleep, 0, sizeof(struct PS_CMD_ConfirmSleep));
 150         adapter->libertas_ps_confirm_sleep.seqnum = cpu_to_le16(++adapter->seqnum);
 151         adapter->libertas_ps_confirm_sleep.command =
 152             cpu_to_le16(cmd_802_11_ps_mode);
 153         adapter->libertas_ps_confirm_sleep.size =
 154             cpu_to_le16(sizeof(struct PS_CMD_ConfirmSleep));
 155         adapter->libertas_ps_confirm_sleep.result = 0;
 156         adapter->libertas_ps_confirm_sleep.action =
 157             cpu_to_le16(cmd_subcmd_sleep_confirmed);
 158
 159         return 0;
 160 }
 161
 162 static void wlan_init_adapter(wlan_private * priv)
 163 {
 164         wlan_adapter *adapter = priv->adapter;
 165         int i;
 166
 167         adapter->scanprobes = 0;
 168
 169         adapter->bcn_avg_factor = DEFAULT_BCN_AVG_FACTOR;
 170         adapter->data_avg_factor = DEFAULT_DATA_AVG_FACTOR;
 171
 172         /* ATIM params */
 173         adapter->atimwindow = 0;
 174
 175         adapter->connect_status = libertas_disconnected;
 176         memset(adapter->current_addr, 0xff, ETH_ALEN);
 177
 178         /* scan type */
 179         adapter->scantype = cmd_scan_type_active;
 180
 181         /* scan mode */
 182         adapter->scanmode = cmd_bss_type_any;
 183
 184         /* 802.11 specific */
 185         adapter->secinfo.wep_enabled = 0;
 186         for (i = 0; i < sizeof(adapter->wep_keys) / sizeof(adapter->wep_keys[0]);
 187              i++)
 188                 memset(&adapter->wep_keys[i], 0, sizeof(struct WLAN_802_11_KEY));
 189         adapter->wep_tx_keyidx = 0;
 190         adapter->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM;
 191         adapter->mode = IW_MODE_INFRA;
 192
 193         adapter->assoc_req = NULL;
 194
 195         adapter->numinscantable = 0;
 196         adapter->pattemptedbssdesc = NULL;
 197         mutex_init(&adapter->lock);
 198
 199         adapter->prescan = 1;
 200
 201         memset(&adapter->curbssparams, 0, sizeof(adapter->curbssparams));
 202
 203         /* PnP and power profile */
 204         adapter->surpriseremoved = 0;
 205
 206         adapter->currentpacketfilter =
 207             cmd_act_mac_rx_on | cmd_act_mac_tx_on;
 208
 209         adapter->radioon = RADIO_ON;
 210         adapter->txantenna = RF_ANTENNA_2;
 211         adapter->rxantenna = RF_ANTENNA_AUTO;
 212
 213         adapter->is_datarate_auto = 1;
 214         adapter->beaconperiod = MRVDRV_BEACON_INTERVAL;
 215
 216         // set default value of capinfo.
 217 #define SHORT_PREAMBLE_ALLOWED          1
 218         memset(&adapter->capinfo, 0, sizeof(adapter->capinfo));
 219         adapter->capinfo.shortpreamble = SHORT_PREAMBLE_ALLOWED;
 220
 221         adapter->adhocchannel = DEFAULT_AD_HOC_CHANNEL;
 222
 223         adapter->psmode = wlan802_11powermodecam;
 224         adapter->multipledtim = MRVDRV_DEFAULT_MULTIPLE_DTIM;
 225
 226         adapter->listeninterval = MRVDRV_DEFAULT_LISTEN_INTERVAL;
 227
 228         adapter->psstate = PS_STATE_FULL_POWER;
 229         adapter->needtowakeup = 0;
 230         adapter->locallisteninterval = 0;       /* default value in firmware will be used */
 231
 232         adapter->datarate = 0;  // Initially indicate the rate as auto
 233
 234         adapter->adhoc_grate_enabled = 0;
 235
 236         adapter->intcounter = 0;
 237
 238         adapter->currenttxskb = NULL;
 239         adapter->pkttxctrl = 0;
 240
 241         memset(&adapter->tx_queue_ps, 0, NR_TX_QUEUE*sizeof(struct sk_buff*));
 242         adapter->tx_queue_idx = 0;
 243         spin_lock_init(&adapter->txqueue_lock);
 244
 245         return;
 246 }
 247
 248 static void command_timer_fn(unsigned long data);
 249
 250 int libertas_init_fw(wlan_private * priv)
 251 {
 252         int ret = -1;
 253         wlan_adapter *adapter = priv->adapter;
 254
 255         lbs_deb_enter(LBS_DEB_FW);
 256
 257         /* Allocate adapter structure */
 258         if ((ret = wlan_allocate_adapter(priv)) != 0)
 259                 goto done;
 260
 261         /* init adapter structure */
 262         wlan_init_adapter(priv);
 263
 264         /* init timer etc. */
 265         setup_timer(&adapter->command_timer, command_timer_fn,
 266                         (unsigned long)priv);
 267
 268         /* download fimrware etc. */
 269         if ((ret = wlan_setup_station_hw(priv)) != 0) {
 270                 del_timer_sync(&adapter->command_timer);
 271                 goto done;
 272         }
 273
 274         /* init 802.11d */
 275         libertas_init_11d(priv);
 276
 277         ret = 0;
 278 done:
 279         lbs_deb_leave_args(LBS_DEB_FW, "ret %d", ret);
 280         return ret;
 281 }
 282
 283 void libertas_free_adapter(wlan_private * priv)
 284 {
 285         wlan_adapter *adapter = priv->adapter;
 286
 287         if (!adapter) {
 288                 lbs_deb_fw("why double free adapter?\n");
 289                 return;
 290         }
 291
 292         lbs_deb_fw("free command buffer\n");
 293         libertas_free_cmd_buffer(priv);
 294
 295         lbs_deb_fw("free command_timer\n");
 296         del_timer(&adapter->command_timer);
 297
 298         lbs_deb_fw("free scantable\n");
 299         if (adapter->scantable) {
 300                 kfree(adapter->scantable);
 301                 adapter->scantable = NULL;
 302         }
 303
 304         /* Free the adapter object itself */
 305         lbs_deb_fw("free adapter\n");
 306         kfree(adapter);
 307         priv->adapter = NULL;
 308 }
 309
 310 /**
 311  *  This function handles the timeout of command sending.
 312  *  It will re-send the same command again.
 313  */
 314 static void command_timer_fn(unsigned long data)
 315 {
 316         wlan_private *priv = (wlan_private *)data;
 317         wlan_adapter *adapter = priv->adapter;
 318         struct cmd_ctrl_node *ptempnode;
 319         struct cmd_ds_command *cmd;
 320         unsigned long flags;
 321
 322         ptempnode = adapter->cur_cmd;
 323         if (ptempnode == NULL) {
 324                 lbs_deb_fw("ptempnode empty\n");
 325                 return;
 326         }
 327
 328         cmd = (struct cmd_ds_command *)ptempnode->bufvirtualaddr;
 329         if (!cmd) {
 330                 lbs_deb_fw("cmd is NULL\n");
 331                 return;
 332         }
 333
 334         lbs_deb_fw("command_timer_fn fired, cmd %x\n", cmd->command);
 335
 336         if (!adapter->fw_ready)
 337                 return;
 338
 339         spin_lock_irqsave(&adapter->driver_lock, flags);
 340         adapter->cur_cmd = NULL;
 341         spin_unlock_irqrestore(&adapter->driver_lock, flags);
 342
 343         lbs_deb_fw("re-sending same command because of timeout\n");
 344         libertas_queue_cmd(adapter, ptempnode, 0);
 345
 346         wake_up_interruptible(&priv->mainthread.waitq);
 347
 348         return;
 349 }