drivers/net/wireless/libertas_tf/cmd.c

   1 /*
   2  *  Copyright (C) 2008, cozybit Inc.
   3  *  Copyright (C) 2003-2006, Marvell International Ltd.
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or (at
   8  *  your option) any later version.
   9  */
  10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  11
  12 #include <linux/slab.h>
  13
  14 #include "libertas_tf.h"
  15
  16 static const struct channel_range channel_ranges[] = {
  17         { LBTF_REGDOMAIN_US,            1, 12 },
  18         { LBTF_REGDOMAIN_CA,            1, 12 },
  19         { LBTF_REGDOMAIN_EU,            1, 14 },
  20         { LBTF_REGDOMAIN_JP,            1, 14 },
  21         { LBTF_REGDOMAIN_SP,            1, 14 },
  22         { LBTF_REGDOMAIN_FR,            1, 14 },
  23 };
  24
  25 static u16 lbtf_region_code_to_index[MRVDRV_MAX_REGION_CODE] =
  26 {
  27         LBTF_REGDOMAIN_US, LBTF_REGDOMAIN_CA, LBTF_REGDOMAIN_EU,
  28         LBTF_REGDOMAIN_SP, LBTF_REGDOMAIN_FR, LBTF_REGDOMAIN_JP,
  29 };
  30
  31 static struct cmd_ctrl_node *lbtf_get_cmd_ctrl_node(struct lbtf_private *priv);
  32
  33
  34 /**
  35  *  lbtf_cmd_copyback - Simple callback that copies response back into command
  36  *
  37  *  @priv       A pointer to struct lbtf_private structure
  38  *  @extra      A pointer to the original command structure for which
  39  *              'resp' is a response
  40  *  @resp       A pointer to the command response
  41  *
  42  *  Returns: 0 on success, error on failure
  43  */
  44 int lbtf_cmd_copyback(struct lbtf_private *priv, unsigned long extra,
  45                      struct cmd_header *resp)
  46 {
  47         struct cmd_header *buf = (void *)extra;
  48         uint16_t copy_len;
  49
  50         copy_len = min(le16_to_cpu(buf->size), le16_to_cpu(resp->size));
  51         memcpy(buf, resp, copy_len);
  52         return 0;
  53 }
  54 EXPORT_SYMBOL_GPL(lbtf_cmd_copyback);
  55
  56 #define CHAN_TO_IDX(chan) ((chan) - 1)
  57
  58 static void lbtf_geo_init(struct lbtf_private *priv)
  59 {
  60         const struct channel_range *range = channel_ranges;
  61         u8 ch;
  62         int i;
  63
  64         for (i = 0; i < ARRAY_SIZE(channel_ranges); i++)
  65                 if (channel_ranges[i].regdomain == priv->regioncode) {
  66                         range = &channel_ranges[i];
  67                         break;
  68                 }
  69
  70         for (ch = priv->range.start; ch < priv->range.end; ch++)
  71                 priv->channels[CHAN_TO_IDX(ch)].flags = 0;
  72 }
  73
  74 /**
  75  *  lbtf_update_hw_spec: Updates the hardware details.
  76  *
  77  *  @priv       A pointer to struct lbtf_private structure
  78  *
  79  *  Returns: 0 on success, error on failure
  80  */
  81 int lbtf_update_hw_spec(struct lbtf_private *priv)
  82 {
  83         struct cmd_ds_get_hw_spec cmd;
  84         int ret = -1;
  85         u32 i;
  86
  87         lbtf_deb_enter(LBTF_DEB_CMD);
  88
  89         memset(&cmd, 0, sizeof(cmd));
  90         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
  91         memcpy(cmd.permanentaddr, priv->current_addr, ETH_ALEN);
  92         ret = lbtf_cmd_with_response(priv, CMD_GET_HW_SPEC, &cmd);
  93         if (ret)
  94                 goto out;
  95
  96         priv->fwcapinfo = le32_to_cpu(cmd.fwcapinfo);
  97
  98         /* The firmware release is in an interesting format: the patch
  99          * level is in the most significant nibble ... so fix that: */
 100         priv->fwrelease = le32_to_cpu(cmd.fwrelease);
 101         priv->fwrelease = (priv->fwrelease << 8) |
 102                 (priv->fwrelease >> 24 & 0xff);
 103
 104         printk(KERN_INFO "libertastf: %pM, fw %u.%u.%up%u, cap 0x%08x\n",
 105                 cmd.permanentaddr,
 106                 priv->fwrelease >> 24 & 0xff,
 107                 priv->fwrelease >> 16 & 0xff,
 108                 priv->fwrelease >>  8 & 0xff,
 109                 priv->fwrelease       & 0xff,
 110                 priv->fwcapinfo);
 111         lbtf_deb_cmd("GET_HW_SPEC: hardware interface 0x%x, hardware spec 0x%04x\n",
 112                     cmd.hwifversion, cmd.version);
 113
 114         /* Clamp region code to 8-bit since FW spec indicates that it should
 115          * only ever be 8-bit, even though the field size is 16-bit.  Some
 116          * firmware returns non-zero high 8 bits here.
 117          */
 118         priv->regioncode = le16_to_cpu(cmd.regioncode) & 0xFF;
 119
 120         for (i = 0; i < MRVDRV_MAX_REGION_CODE; i++) {
 121                 /* use the region code to search for the index */
 122                 if (priv->regioncode == lbtf_region_code_to_index[i])
 123                         break;
 124         }
 125
 126         /* if it's unidentified region code, use the default (USA) */
 127         if (i >= MRVDRV_MAX_REGION_CODE) {
 128                 priv->regioncode = 0x10;
 129                 pr_info("unidentified region code; using the default (USA)\n");
 130         }
 131
 132         if (priv->current_addr[0] == 0xff)
 133                 memmove(priv->current_addr, cmd.permanentaddr, ETH_ALEN);
 134
 135         SET_IEEE80211_PERM_ADDR(priv->hw, priv->current_addr);
 136
 137         lbtf_geo_init(priv);
 138 out:
 139         lbtf_deb_leave(LBTF_DEB_CMD);
 140         return ret;
 141 }
 142
 143 /**
 144  *  lbtf_set_channel: Set the radio channel
 145  *
 146  *  @priv       A pointer to struct lbtf_private structure
 147  *  @channel    The desired channel, or 0 to clear a locked channel
 148  *
 149  *  Returns: 0 on success, error on failure
 150  */
 151 int lbtf_set_channel(struct lbtf_private *priv, u8 channel)
 152 {
 153         int ret = 0;
 154         struct cmd_ds_802_11_rf_channel cmd;
 155
 156         lbtf_deb_enter(LBTF_DEB_CMD);
 157
 158         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
 159         cmd.action = cpu_to_le16(CMD_OPT_802_11_RF_CHANNEL_SET);
 160         cmd.channel = cpu_to_le16(channel);
 161
 162         ret = lbtf_cmd_with_response(priv, CMD_802_11_RF_CHANNEL, &cmd);
 163         lbtf_deb_leave_args(LBTF_DEB_CMD, "ret %d", ret);
 164         return ret;
 165 }
 166
 167 int lbtf_beacon_set(struct lbtf_private *priv, struct sk_buff *beacon)
 168 {
 169         struct cmd_ds_802_11_beacon_set cmd;
 170         int size;
 171
 172         lbtf_deb_enter(LBTF_DEB_CMD);
 173
 174         if (beacon->len > MRVL_MAX_BCN_SIZE) {
 175                 lbtf_deb_leave_args(LBTF_DEB_CMD, "ret %d", -1);
 176                 return -1;
 177         }
 178         size =  sizeof(cmd) - sizeof(cmd.beacon) + beacon->len;
 179         cmd.hdr.size = cpu_to_le16(size);
 180         cmd.len = cpu_to_le16(beacon->len);
 181         memcpy(cmd.beacon, (u8 *) beacon->data, beacon->len);
 182
 183         lbtf_cmd_async(priv, CMD_802_11_BEACON_SET, &cmd.hdr, size);
 184
 185         lbtf_deb_leave_args(LBTF_DEB_CMD, "ret %d", 0);
 186         return 0;
 187 }
 188
 189 int lbtf_beacon_ctrl(struct lbtf_private *priv, bool beacon_enable,
 190                      int beacon_int)
 191 {
 192         struct cmd_ds_802_11_beacon_control cmd;
 193         lbtf_deb_enter(LBTF_DEB_CMD);
 194
 195         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
 196         cmd.action = cpu_to_le16(CMD_ACT_SET);
 197         cmd.beacon_enable = cpu_to_le16(beacon_enable);
 198         cmd.beacon_period = cpu_to_le16(beacon_int);
 199
 200         lbtf_cmd_async(priv, CMD_802_11_BEACON_CTRL, &cmd.hdr, sizeof(cmd));
 201
 202         lbtf_deb_leave(LBTF_DEB_CMD);
 203         return 0;
 204 }
 205
 206 static void lbtf_queue_cmd(struct lbtf_private *priv,
 207                           struct cmd_ctrl_node *cmdnode)
 208 {
 209         unsigned long flags;
 210         lbtf_deb_enter(LBTF_DEB_HOST);
 211
 212         if (!cmdnode) {
 213                 lbtf_deb_host("QUEUE_CMD: cmdnode is NULL\n");
 214                 goto qcmd_done;
 215         }
 216
 217         if (!cmdnode->cmdbuf->size) {
 218                 lbtf_deb_host("DNLD_CMD: cmd size is zero\n");
 219                 goto qcmd_done;
 220         }
 221
 222         cmdnode->result = 0;
 223         spin_lock_irqsave(&priv->driver_lock, flags);
 224         list_add_tail(&cmdnode->list, &priv->cmdpendingq);
 225         spin_unlock_irqrestore(&priv->driver_lock, flags);
 226
 227         lbtf_deb_host("QUEUE_CMD: inserted command 0x%04x into cmdpendingq\n",
 228                      le16_to_cpu(cmdnode->cmdbuf->command));
 229
 230 qcmd_done:
 231         lbtf_deb_leave(LBTF_DEB_HOST);
 232 }
 233
 234 static void lbtf_submit_command(struct lbtf_private *priv,
 235                                struct cmd_ctrl_node *cmdnode)
 236 {
 237         unsigned long flags;
 238         struct cmd_header *cmd;
 239         uint16_t cmdsize;
 240         uint16_t command;
 241         int timeo = 5 * HZ;
 242         int ret;
 243
 244         lbtf_deb_enter(LBTF_DEB_HOST);
 245
 246         cmd = cmdnode->cmdbuf;
 247
 248         spin_lock_irqsave(&priv->driver_lock, flags);
 249         priv->cur_cmd = cmdnode;
 250         cmdsize = le16_to_cpu(cmd->size);
 251         command = le16_to_cpu(cmd->command);
 252
 253         lbtf_deb_cmd("DNLD_CMD: command 0x%04x, seq %d, size %d\n",
 254                      command, le16_to_cpu(cmd->seqnum), cmdsize);
 255         lbtf_deb_hex(LBTF_DEB_CMD, "DNLD_CMD", (void *) cmdnode->cmdbuf, cmdsize);
 256
 257         ret = priv->hw_host_to_card(priv, MVMS_CMD, (u8 *) cmd, cmdsize);
 258         spin_unlock_irqrestore(&priv->driver_lock, flags);
 259
 260         if (ret) {
 261                 pr_info("DNLD_CMD: hw_host_to_card failed: %d\n", ret);
 262                 /* Let the timer kick in and retry, and potentially reset
 263                    the whole thing if the condition persists */
 264                 timeo = HZ;
 265         }
 266
 267         /* Setup the timer after transmit command */
 268         mod_timer(&priv->command_timer, jiffies + timeo);
 269
 270         lbtf_deb_leave(LBTF_DEB_HOST);
 271 }
 272
 273 /**
 274  *  This function inserts command node to cmdfreeq
 275  *  after cleans it. Requires priv->driver_lock held.
 276  */
 277 static void __lbtf_cleanup_and_insert_cmd(struct lbtf_private *priv,
 278                                          struct cmd_ctrl_node *cmdnode)
 279 {
 280         lbtf_deb_enter(LBTF_DEB_HOST);
 281
 282         if (!cmdnode)
 283                 goto cl_ins_out;
 284
 285         cmdnode->callback = NULL;
 286         cmdnode->callback_arg = 0;
 287
 288         memset(cmdnode->cmdbuf, 0, LBS_CMD_BUFFER_SIZE);
 289
 290         list_add_tail(&cmdnode->list, &priv->cmdfreeq);
 291
 292 cl_ins_out:
 293         lbtf_deb_leave(LBTF_DEB_HOST);
 294 }
 295
 296 static void lbtf_cleanup_and_insert_cmd(struct lbtf_private *priv,
 297         struct cmd_ctrl_node *ptempcmd)
 298 {
 299         unsigned long flags;
 300
 301         spin_lock_irqsave(&priv->driver_lock, flags);
 302         __lbtf_cleanup_and_insert_cmd(priv, ptempcmd);
 303         spin_unlock_irqrestore(&priv->driver_lock, flags);
 304 }
 305
 306 void lbtf_complete_command(struct lbtf_private *priv, struct cmd_ctrl_node *cmd,
 307                           int result)
 308 {
 309         cmd->result = result;
 310         cmd->cmdwaitqwoken = 1;
 311         wake_up_interruptible(&cmd->cmdwait_q);
 312
 313         if (!cmd->callback)
 314                 __lbtf_cleanup_and_insert_cmd(priv, cmd);
 315         priv->cur_cmd = NULL;
 316 }
 317
 318 int lbtf_cmd_set_mac_multicast_addr(struct lbtf_private *priv)
 319 {
 320         struct cmd_ds_mac_multicast_addr cmd;
 321
 322         lbtf_deb_enter(LBTF_DEB_CMD);
 323
 324         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
 325         cmd.action = cpu_to_le16(CMD_ACT_SET);
 326
 327         cmd.nr_of_adrs = cpu_to_le16((u16) priv->nr_of_multicastmacaddr);
 328
 329         lbtf_deb_cmd("MULTICAST_ADR: setting %d addresses\n", cmd.nr_of_adrs);
 330
 331         memcpy(cmd.maclist, priv->multicastlist,
 332                priv->nr_of_multicastmacaddr * ETH_ALEN);
 333
 334         lbtf_cmd_async(priv, CMD_MAC_MULTICAST_ADR, &cmd.hdr, sizeof(cmd));
 335
 336         lbtf_deb_leave(LBTF_DEB_CMD);
 337         return 0;
 338 }
 339
 340 void lbtf_set_mode(struct lbtf_private *priv, enum lbtf_mode mode)
 341 {
 342         struct cmd_ds_set_mode cmd;
 343         lbtf_deb_enter(LBTF_DEB_WEXT);
 344
 345         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
 346         cmd.mode = cpu_to_le16(mode);
 347         lbtf_deb_wext("Switching to mode: 0x%x\n", mode);
 348         lbtf_cmd_async(priv, CMD_802_11_SET_MODE, &cmd.hdr, sizeof(cmd));
 349
 350         lbtf_deb_leave(LBTF_DEB_WEXT);
 351 }
 352
 353 void lbtf_set_bssid(struct lbtf_private *priv, bool activate, const u8 *bssid)
 354 {
 355         struct cmd_ds_set_bssid cmd;
 356         lbtf_deb_enter(LBTF_DEB_CMD);
 357
 358         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
 359         cmd.activate = activate ? 1 : 0;
 360         if (activate)
 361                 memcpy(cmd.bssid, bssid, ETH_ALEN);
 362
 363         lbtf_cmd_async(priv, CMD_802_11_SET_BSSID, &cmd.hdr, sizeof(cmd));
 364         lbtf_deb_leave(LBTF_DEB_CMD);
 365 }
 366
 367 int lbtf_set_mac_address(struct lbtf_private *priv, uint8_t *mac_addr)
 368 {
 369         struct cmd_ds_802_11_mac_address cmd;
 370         lbtf_deb_enter(LBTF_DEB_CMD);
 371
 372         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
 373         cmd.action = cpu_to_le16(CMD_ACT_SET);
 374
 375         memcpy(cmd.macadd, mac_addr, ETH_ALEN);
 376
 377         lbtf_cmd_async(priv, CMD_802_11_MAC_ADDRESS, &cmd.hdr, sizeof(cmd));
 378         lbtf_deb_leave(LBTF_DEB_CMD);
 379         return 0;
 380 }
 381
 382 int lbtf_set_radio_control(struct lbtf_private *priv)
 383 {
 384         int ret = 0;
 385         struct cmd_ds_802_11_radio_control cmd;
 386
 387         lbtf_deb_enter(LBTF_DEB_CMD);
 388
 389         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
 390         cmd.action = cpu_to_le16(CMD_ACT_SET);
 391
 392         switch (priv->preamble) {
 393         case CMD_TYPE_SHORT_PREAMBLE:
 394                 cmd.control = cpu_to_le16(SET_SHORT_PREAMBLE);
 395                 break;
 396
 397         case CMD_TYPE_LONG_PREAMBLE:
 398                 cmd.control = cpu_to_le16(SET_LONG_PREAMBLE);
 399                 break;
 400
 401         case CMD_TYPE_AUTO_PREAMBLE:
 402         default:
 403                 cmd.control = cpu_to_le16(SET_AUTO_PREAMBLE);
 404                 break;
 405         }
 406
 407         if (priv->radioon)
 408                 cmd.control |= cpu_to_le16(TURN_ON_RF);
 409         else
 410                 cmd.control &= cpu_to_le16(~TURN_ON_RF);
 411
 412         lbtf_deb_cmd("RADIO_SET: radio %d, preamble %d\n", priv->radioon,
 413                     priv->preamble);
 414
 415         ret = lbtf_cmd_with_response(priv, CMD_802_11_RADIO_CONTROL, &cmd);
 416
 417         lbtf_deb_leave_args(LBTF_DEB_CMD, "ret %d", ret);
 418         return ret;
 419 }
 420
 421 void lbtf_set_mac_control(struct lbtf_private *priv)
 422 {
 423         struct cmd_ds_mac_control cmd;
 424         lbtf_deb_enter(LBTF_DEB_CMD);
 425
 426         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
 427         cmd.action = cpu_to_le16(priv->mac_control);
 428         cmd.reserved = 0;
 429
 430         lbtf_cmd_async(priv, CMD_MAC_CONTROL,
 431                 &cmd.hdr, sizeof(cmd));
 432
 433         lbtf_deb_leave(LBTF_DEB_CMD);
 434 }
 435
 436 /**
 437  *  lbtf_allocate_cmd_buffer - Allocates cmd buffer, links it to free cmd queue
 438  *
 439  *  @priv       A pointer to struct lbtf_private structure
 440  *
 441  *  Returns: 0 on success.
 442  */
 443 int lbtf_allocate_cmd_buffer(struct lbtf_private *priv)
 444 {
 445         int ret = 0;
 446         u32 bufsize;
 447         u32 i;
 448         struct cmd_ctrl_node *cmdarray;
 449
 450         lbtf_deb_enter(LBTF_DEB_HOST);
 451
 452         /* Allocate and initialize the command array */
 453         bufsize = sizeof(struct cmd_ctrl_node) * LBS_NUM_CMD_BUFFERS;
 454         cmdarray = kzalloc(bufsize, GFP_KERNEL);
 455         if (!cmdarray) {
 456                 lbtf_deb_host("ALLOC_CMD_BUF: tempcmd_array is NULL\n");
 457                 ret = -1;
 458                 goto done;
 459         }
 460         priv->cmd_array = cmdarray;
 461
 462         /* Allocate and initialize each command buffer in the command array */
 463         for (i = 0; i < LBS_NUM_CMD_BUFFERS; i++) {
 464                 cmdarray[i].cmdbuf = kzalloc(LBS_CMD_BUFFER_SIZE, GFP_KERNEL);
 465                 if (!cmdarray[i].cmdbuf) {
 466                         lbtf_deb_host("ALLOC_CMD_BUF: ptempvirtualaddr is NULL\n");
 467                         ret = -1;
 468                         goto done;
 469                 }
 470         }
 471
 472         for (i = 0; i < LBS_NUM_CMD_BUFFERS; i++) {
 473                 init_waitqueue_head(&cmdarray[i].cmdwait_q);
 474                 lbtf_cleanup_and_insert_cmd(priv, &cmdarray[i]);
 475         }
 476
 477         ret = 0;
 478
 479 done:
 480         lbtf_deb_leave_args(LBTF_DEB_HOST, "ret %d", ret);
 481         return ret;
 482 }
 483
 484 /**
 485  *  lbtf_free_cmd_buffer - Frees the cmd buffer.
 486  *
 487  *  @priv       A pointer to struct lbtf_private structure
 488  *
 489  *  Returns: 0
 490  */
 491 int lbtf_free_cmd_buffer(struct lbtf_private *priv)
 492 {
 493         struct cmd_ctrl_node *cmdarray;
 494         unsigned int i;
 495
 496         lbtf_deb_enter(LBTF_DEB_HOST);
 497
 498         /* need to check if cmd array is allocated or not */
 499         if (priv->cmd_array == NULL) {
 500                 lbtf_deb_host("FREE_CMD_BUF: cmd_array is NULL\n");
 501                 goto done;
 502         }
 503
 504         cmdarray = priv->cmd_array;
 505
 506         /* Release shared memory buffers */
 507         for (i = 0; i < LBS_NUM_CMD_BUFFERS; i++) {
 508                 kfree(cmdarray[i].cmdbuf);
 509                 cmdarray[i].cmdbuf = NULL;
 510         }
 511
 512         /* Release cmd_ctrl_node */
 513         kfree(priv->cmd_array);
 514         priv->cmd_array = NULL;
 515
 516 done:
 517         lbtf_deb_leave(LBTF_DEB_HOST);
 518         return 0;
 519 }
 520
 521 /**
 522  *  lbtf_get_cmd_ctrl_node - Gets free cmd node from free cmd queue.
 523  *
 524  *  @priv               A pointer to struct lbtf_private structure
 525  *
 526  *  Returns: pointer to a struct cmd_ctrl_node or NULL if none available.
 527  */
 528 static struct cmd_ctrl_node *lbtf_get_cmd_ctrl_node(struct lbtf_private *priv)
 529 {
 530         struct cmd_ctrl_node *tempnode;
 531         unsigned long flags;
 532
 533         lbtf_deb_enter(LBTF_DEB_HOST);
 534
 535         if (!priv)
 536                 return NULL;
 537
 538         spin_lock_irqsave(&priv->driver_lock, flags);
 539
 540         if (!list_empty(&priv->cmdfreeq)) {
 541                 tempnode = list_first_entry(&priv->cmdfreeq,
 542                                             struct cmd_ctrl_node, list);
 543                 list_del(&tempnode->list);
 544         } else {
 545                 lbtf_deb_host("GET_CMD_NODE: cmd_ctrl_node is not available\n");
 546                 tempnode = NULL;
 547         }
 548
 549         spin_unlock_irqrestore(&priv->driver_lock, flags);
 550
 551         lbtf_deb_leave(LBTF_DEB_HOST);
 552         return tempnode;
 553 }
 554
 555 /**
 556  *  lbtf_execute_next_command: execute next command in cmd pending queue.
 557  *
 558  *  @priv     A pointer to struct lbtf_private structure
 559  *
 560  *  Returns: 0 on success.
 561  */
 562 int lbtf_execute_next_command(struct lbtf_private *priv)
 563 {
 564         struct cmd_ctrl_node *cmdnode = NULL;
 565         struct cmd_header *cmd;
 566         unsigned long flags;
 567         int ret = 0;
 568
 569         /* Debug group is lbtf_deb_THREAD and not lbtf_deb_HOST, because the
 570          * only caller to us is lbtf_thread() and we get even when a
 571          * data packet is received */
 572         lbtf_deb_enter(LBTF_DEB_THREAD);
 573
 574         spin_lock_irqsave(&priv->driver_lock, flags);
 575
 576         if (priv->cur_cmd) {
 577                 pr_alert("EXEC_NEXT_CMD: already processing command!\n");
 578                 spin_unlock_irqrestore(&priv->driver_lock, flags);
 579                 ret = -1;
 580                 goto done;
 581         }
 582
 583         if (!list_empty(&priv->cmdpendingq)) {
 584                 cmdnode = list_first_entry(&priv->cmdpendingq,
 585                                            struct cmd_ctrl_node, list);
 586         }
 587
 588         if (cmdnode) {
 589                 cmd = cmdnode->cmdbuf;
 590
 591                 list_del(&cmdnode->list);
 592                 lbtf_deb_host("EXEC_NEXT_CMD: sending command 0x%04x\n",
 593                             le16_to_cpu(cmd->command));
 594                 spin_unlock_irqrestore(&priv->driver_lock, flags);
 595                 lbtf_submit_command(priv, cmdnode);
 596         } else
 597                 spin_unlock_irqrestore(&priv->driver_lock, flags);
 598
 599         ret = 0;
 600 done:
 601         lbtf_deb_leave(LBTF_DEB_THREAD);
 602         return ret;
 603 }
 604
 605 static struct cmd_ctrl_node *__lbtf_cmd_async(struct lbtf_private *priv,
 606         uint16_t command, struct cmd_header *in_cmd, int in_cmd_size,
 607         int (*callback)(struct lbtf_private *, unsigned long,
 608                         struct cmd_header *),
 609         unsigned long callback_arg)
 610 {
 611         struct cmd_ctrl_node *cmdnode;
 612
 613         lbtf_deb_enter(LBTF_DEB_HOST);
 614
 615         if (priv->surpriseremoved) {
 616                 lbtf_deb_host("PREP_CMD: card removed\n");
 617                 cmdnode = ERR_PTR(-ENOENT);
 618                 goto done;
 619         }
 620
 621         cmdnode = lbtf_get_cmd_ctrl_node(priv);
 622         if (cmdnode == NULL) {
 623                 lbtf_deb_host("PREP_CMD: cmdnode is NULL\n");
 624
 625                 /* Wake up main thread to execute next command */
 626                 queue_work(lbtf_wq, &priv->cmd_work);
 627                 cmdnode = ERR_PTR(-ENOBUFS);
 628                 goto done;
 629         }
 630
 631         cmdnode->callback = callback;
 632         cmdnode->callback_arg = callback_arg;
 633
 634         /* Copy the incoming command to the buffer */
 635         memcpy(cmdnode->cmdbuf, in_cmd, in_cmd_size);
 636
 637         /* Set sequence number, clean result, move to buffer */
 638         priv->seqnum++;
 639         cmdnode->cmdbuf->command = cpu_to_le16(command);
 640         cmdnode->cmdbuf->size    = cpu_to_le16(in_cmd_size);
 641         cmdnode->cmdbuf->seqnum  = cpu_to_le16(priv->seqnum);
 642         cmdnode->cmdbuf->result  = 0;
 643
 644         lbtf_deb_host("PREP_CMD: command 0x%04x\n", command);
 645
 646         cmdnode->cmdwaitqwoken = 0;
 647         lbtf_queue_cmd(priv, cmdnode);
 648         queue_work(lbtf_wq, &priv->cmd_work);
 649
 650  done:
 651         lbtf_deb_leave_args(LBTF_DEB_HOST, "ret %p", cmdnode);
 652         return cmdnode;
 653 }
 654
 655 void lbtf_cmd_async(struct lbtf_private *priv, uint16_t command,
 656         struct cmd_header *in_cmd, int in_cmd_size)
 657 {
 658         lbtf_deb_enter(LBTF_DEB_CMD);
 659         __lbtf_cmd_async(priv, command, in_cmd, in_cmd_size, NULL, 0);
 660         lbtf_deb_leave(LBTF_DEB_CMD);
 661 }
 662
 663 int __lbtf_cmd(struct lbtf_private *priv, uint16_t command,
 664               struct cmd_header *in_cmd, int in_cmd_size,
 665               int (*callback)(struct lbtf_private *,
 666                               unsigned long, struct cmd_header *),
 667               unsigned long callback_arg)
 668 {
 669         struct cmd_ctrl_node *cmdnode;
 670         unsigned long flags;
 671         int ret = 0;
 672
 673         lbtf_deb_enter(LBTF_DEB_HOST);
 674
 675         cmdnode = __lbtf_cmd_async(priv, command, in_cmd, in_cmd_size,
 676                                   callback, callback_arg);
 677         if (IS_ERR(cmdnode)) {
 678                 ret = PTR_ERR(cmdnode);
 679                 goto done;
 680         }
 681
 682         might_sleep();
 683         ret = wait_event_interruptible(cmdnode->cmdwait_q,
 684                                        cmdnode->cmdwaitqwoken);
 685         if (ret) {
 686                 pr_info("PREP_CMD: command 0x%04x interrupted by signal: %d\n",
 687                             command, ret);
 688                 goto done;
 689         }
 690
 691         spin_lock_irqsave(&priv->driver_lock, flags);
 692         ret = cmdnode->result;
 693         if (ret)
 694                 pr_info("PREP_CMD: command 0x%04x failed: %d\n",
 695                             command, ret);
 696
 697         __lbtf_cleanup_and_insert_cmd(priv, cmdnode);
 698         spin_unlock_irqrestore(&priv->driver_lock, flags);
 699
 700 done:
 701         lbtf_deb_leave_args(LBTF_DEB_HOST, "ret %d", ret);
 702         return ret;
 703 }
 704 EXPORT_SYMBOL_GPL(__lbtf_cmd);
 705
 706 /* Call holding driver_lock */
 707 void lbtf_cmd_response_rx(struct lbtf_private *priv)
 708 {
 709         priv->cmd_response_rxed = 1;
 710         queue_work(lbtf_wq, &priv->cmd_work);
 711 }
 712 EXPORT_SYMBOL_GPL(lbtf_cmd_response_rx);
 713
 714 int lbtf_process_rx_command(struct lbtf_private *priv)
 715 {
 716         uint16_t respcmd, curcmd;
 717         struct cmd_header *resp;
 718         int ret = 0;
 719         unsigned long flags;
 720         uint16_t result;
 721
 722         lbtf_deb_enter(LBTF_DEB_CMD);
 723
 724         mutex_lock(&priv->lock);
 725         spin_lock_irqsave(&priv->driver_lock, flags);
 726
 727         if (!priv->cur_cmd) {
 728                 ret = -1;
 729                 spin_unlock_irqrestore(&priv->driver_lock, flags);
 730                 goto done;
 731         }
 732
 733         resp = (void *)priv->cmd_resp_buff;
 734         curcmd = le16_to_cpu(priv->cur_cmd->cmdbuf->command);
 735         respcmd = le16_to_cpu(resp->command);
 736         result = le16_to_cpu(resp->result);
 737
 738         if (net_ratelimit())
 739                 pr_info("libertastf: cmd response 0x%04x, seq %d, size %d\n",
 740                         respcmd, le16_to_cpu(resp->seqnum),
 741                         le16_to_cpu(resp->size));
 742
 743         if (resp->seqnum != priv->cur_cmd->cmdbuf->seqnum) {
 744                 spin_unlock_irqrestore(&priv->driver_lock, flags);
 745                 ret = -1;
 746                 goto done;
 747         }
 748         if (respcmd != CMD_RET(curcmd)) {
 749                 spin_unlock_irqrestore(&priv->driver_lock, flags);
 750                 ret = -1;
 751                 goto done;
 752         }
 753
 754         if (resp->result == cpu_to_le16(0x0004)) {
 755                 /* 0x0004 means -EAGAIN. Drop the response, let it time out
 756                    and be resubmitted */
 757                 spin_unlock_irqrestore(&priv->driver_lock, flags);
 758                 ret = -1;
 759                 goto done;
 760         }
 761
 762         /* Now we got response from FW, cancel the command timer */
 763         del_timer(&priv->command_timer);
 764         priv->cmd_timed_out = 0;
 765         if (priv->nr_retries)
 766                 priv->nr_retries = 0;
 767
 768         /* If the command is not successful, cleanup and return failure */
 769         if ((result != 0 || !(respcmd & 0x8000))) {
 770                 /*
 771                  * Handling errors here
 772                  */
 773                 switch (respcmd) {
 774                 case CMD_RET(CMD_GET_HW_SPEC):
 775                 case CMD_RET(CMD_802_11_RESET):
 776                         pr_info("libertastf: reset failed\n");
 777                         break;
 778
 779                 }
 780                 lbtf_complete_command(priv, priv->cur_cmd, result);
 781                 spin_unlock_irqrestore(&priv->driver_lock, flags);
 782
 783                 ret = -1;
 784                 goto done;
 785         }
 786
 787         spin_unlock_irqrestore(&priv->driver_lock, flags);
 788
 789         if (priv->cur_cmd && priv->cur_cmd->callback) {
 790                 ret = priv->cur_cmd->callback(priv, priv->cur_cmd->callback_arg,
 791                                 resp);
 792         }
 793         spin_lock_irqsave(&priv->driver_lock, flags);
 794
 795         if (priv->cur_cmd) {
 796                 /* Clean up and Put current command back to cmdfreeq */
 797                 lbtf_complete_command(priv, priv->cur_cmd, result);
 798         }
 799         spin_unlock_irqrestore(&priv->driver_lock, flags);
 800
 801 done:
 802         mutex_unlock(&priv->lock);
 803         lbtf_deb_leave_args(LBTF_DEB_CMD, "ret %d", ret);
 804         return ret;
 805 }