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