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