main.c 28.4 KB
Newer Older
1 2 3 4 5
/*
 * This file contains the major functions in WLAN
 * driver. It includes init, exit, open, close and main
 * thread etc..
 */
6

7 8
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

9
#include <linux/moduleparam.h>
10 11
#include <linux/delay.h>
#include <linux/etherdevice.h>
12
#include <linux/hardirq.h>
13 14
#include <linux/netdevice.h>
#include <linux/if_arp.h>
15
#include <linux/kthread.h>
16
#include <linux/kfifo.h>
17
#include <linux/slab.h>
18
#include <net/cfg80211.h>
19 20 21 22

#include "host.h"
#include "decl.h"
#include "dev.h"
23
#include "cfg.h"
24
#include "debugfs.h"
25
#include "cmd.h"
26

27
#define DRIVER_RELEASE_VERSION "323.p0"
28
const char lbs_driver_version[] = "COMM-USB8388-" DRIVER_RELEASE_VERSION
29 30 31 32 33
#ifdef  DEBUG
    "-dbg"
#endif
    "";

34 35

/* Module parameters */
36 37 38
unsigned int lbs_debug;
EXPORT_SYMBOL_GPL(lbs_debug);
module_param_named(libertas_debug, lbs_debug, int, 0644);
39

40 41 42 43
unsigned int lbs_disablemesh;
EXPORT_SYMBOL_GPL(lbs_disablemesh);
module_param_named(libertas_disablemesh, lbs_disablemesh, int, 0644);

44

45 46 47 48
/*
 * This global structure is used to send the confirm_sleep command as
 * fast as possible down to the firmware.
 */
49 50 51
struct cmd_confirm_sleep confirm_sleep;


52
/*
53
 * the table to keep region code
54
 */
55
u16 lbs_region_code_to_index[MRVDRV_MAX_REGION_CODE] =
56
    { 0x10, 0x20, 0x30, 0x31, 0x32, 0x40 };
57

58
/*
59 60 61
 * FW rate table.  FW refers to rates by their index in this table, not by the
 * rate value itself.  Values of 0x00 are
 * reserved positions.
62
 */
63 64 65 66
static u8 fw_data_rates[MAX_RATES] =
    { 0x02, 0x04, 0x0B, 0x16, 0x00, 0x0C, 0x12,
      0x18, 0x24, 0x30, 0x48, 0x60, 0x6C, 0x00
};
67 68

/**
69
 *  lbs_fw_index_to_data_rate - use index to get the data rate
70
 *
71 72
 *  @idx:	The index of data rate
 *  returns:	data rate or 0
73
 */
74
u32 lbs_fw_index_to_data_rate(u8 idx)
75 76 77 78 79 80 81
{
	if (idx >= sizeof(fw_data_rates))
		idx = 0;
	return fw_data_rates[idx];
}

/**
82
 *  lbs_data_rate_to_fw_index - use rate to get the index
83
 *
84 85
 *  @rate:	data rate
 *  returns:	index or 0
86
 */
87
u8 lbs_data_rate_to_fw_index(u32 rate)
88 89 90 91 92 93 94 95 96 97 98 99
{
	u8 i;

	if (!rate)
		return 0;

	for (i = 0; i < sizeof(fw_data_rates); i++) {
		if (rate == fw_data_rates[i])
			return i;
	}
	return 0;
}
100

101

102
/**
103
 *  lbs_dev_open - open the ethX interface
104
 *
105 106
 *  @dev:	A pointer to &net_device structure
 *  returns:	0 or -EBUSY if monitor mode active
107
 */
108
static int lbs_dev_open(struct net_device *dev)
109
{
110
	struct lbs_private *priv = dev->ml_priv;
111
	int ret = 0;
112

113 114
	lbs_deb_enter(LBS_DEB_NET);

115
	spin_lock_irq(&priv->driver_lock);
116
	priv->stopping = false;
117

118 119 120 121
	if (priv->connect_status == LBS_CONNECTED)
		netif_carrier_on(dev);
	else
		netif_carrier_off(dev);
122

123 124
	if (!priv->tx_pending_len)
		netif_wake_queue(dev);
125

126
	spin_unlock_irq(&priv->driver_lock);
127
	lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret);
128
	return ret;
129 130 131
}

/**
132
 *  lbs_eth_stop - close the ethX interface
133
 *
134 135
 *  @dev:	A pointer to &net_device structure
 *  returns:	0
136
 */
137
static int lbs_eth_stop(struct net_device *dev)
138
{
139
	struct lbs_private *priv = dev->ml_priv;
140

141
	lbs_deb_enter(LBS_DEB_NET);
142

143
	spin_lock_irq(&priv->driver_lock);
144
	priv->stopping = true;
145 146
	netif_stop_queue(dev);
	spin_unlock_irq(&priv->driver_lock);
147

148
	schedule_work(&priv->mcast_work);
149 150 151 152 153
	cancel_delayed_work_sync(&priv->scan_work);
	if (priv->scan_req) {
		cfg80211_scan_done(priv->scan_req, false);
		priv->scan_req = NULL;
	}
154

155
	lbs_deb_leave(LBS_DEB_NET);
156
	return 0;
157 158
}

159 160
void lbs_host_to_card_done(struct lbs_private *priv)
{
161 162
	unsigned long flags;

163 164
	lbs_deb_enter(LBS_DEB_THREAD);

165
	spin_lock_irqsave(&priv->driver_lock, flags);
166 167 168 169

	priv->dnld_sent = DNLD_RES_RECEIVED;

	/* Wake main thread if commands are pending */
170 171 172 173
	if (!priv->cur_cmd || priv->tx_pending_len > 0) {
		if (!priv->wakeup_dev_required)
			wake_up_interruptible(&priv->waitq);
	}
174

175
	spin_unlock_irqrestore(&priv->driver_lock, flags);
176
	lbs_deb_leave(LBS_DEB_THREAD);
177 178 179
}
EXPORT_SYMBOL_GPL(lbs_host_to_card_done);

180
int lbs_set_mac_address(struct net_device *dev, void *addr)
181 182
{
	int ret = 0;
183
	struct lbs_private *priv = dev->ml_priv;
184
	struct sockaddr *phwaddr = addr;
185
	struct cmd_ds_802_11_mac_address cmd;
186

187
	lbs_deb_enter(LBS_DEB_NET);
188

189
	/* In case it was called from the mesh device */
190
	dev = priv->dev;
191

192 193 194
	cmd.hdr.size = cpu_to_le16(sizeof(cmd));
	cmd.action = cpu_to_le16(CMD_ACT_SET);
	memcpy(cmd.macadd, phwaddr->sa_data, ETH_ALEN);
195

196
	ret = lbs_cmd_with_response(priv, CMD_802_11_MAC_ADDRESS, &cmd);
197
	if (ret) {
198
		lbs_deb_net("set MAC address failed\n");
199 200 201
		goto done;
	}

202 203
	memcpy(priv->current_addr, phwaddr->sa_data, ETH_ALEN);
	memcpy(dev->dev_addr, phwaddr->sa_data, ETH_ALEN);
204
	if (priv->mesh_dev)
205
		memcpy(priv->mesh_dev->dev_addr, phwaddr->sa_data, ETH_ALEN);
206 207

done:
208
	lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret);
209 210 211
	return ret;
}

212 213 214

static inline int mac_in_list(unsigned char *list, int list_len,
			      unsigned char *mac)
215
{
216 217 218 219 220 221 222 223 224
	while (list_len) {
		if (!memcmp(list, mac, ETH_ALEN))
			return 1;
		list += ETH_ALEN;
		list_len--;
	}
	return 0;
}

225

226 227 228 229
static int lbs_add_mcast_addrs(struct cmd_ds_mac_multicast_adr *cmd,
			       struct net_device *dev, int nr_addrs)
{
	int i = nr_addrs;
230
	struct netdev_hw_addr *ha;
231
	int cnt;
232 233 234 235

	if ((dev->flags & (IFF_UP|IFF_MULTICAST)) != (IFF_UP|IFF_MULTICAST))
		return nr_addrs;

236
	netif_addr_lock_bh(dev);
237
	cnt = netdev_mc_count(dev);
238 239
	netdev_for_each_mc_addr(ha, dev) {
		if (mac_in_list(cmd->maclist, nr_addrs, ha->addr)) {
J
Johannes Berg 已提交
240
			lbs_deb_net("mcast address %s:%pM skipped\n", dev->name,
241
				    ha->addr);
242
			cnt--;
243 244
			continue;
		}
245

246 247
		if (i == MRVDRV_MAX_MULTICAST_LIST_SIZE)
			break;
248
		memcpy(&cmd->maclist[6*i], ha->addr, ETH_ALEN);
J
Johannes Berg 已提交
249
		lbs_deb_net("mcast address %s:%pM added to filter\n", dev->name,
250
			    ha->addr);
251
		i++;
252
		cnt--;
253
	}
254
	netif_addr_unlock_bh(dev);
255
	if (cnt)
256 257
		return -EOVERFLOW;

258 259 260
	return i;
}

261
static void lbs_set_mcast_worker(struct work_struct *work)
262
{
263 264 265 266 267
	struct lbs_private *priv = container_of(work, struct lbs_private, mcast_work);
	struct cmd_ds_mac_multicast_adr mcast_cmd;
	int dev_flags;
	int nr_addrs;
	int old_mac_control = priv->mac_control;
268

269
	lbs_deb_enter(LBS_DEB_NET);
270

271 272 273 274 275 276 277 278 279 280 281 282 283 284 285
	dev_flags = priv->dev->flags;
	if (priv->mesh_dev)
		dev_flags |= priv->mesh_dev->flags;

	if (dev_flags & IFF_PROMISC) {
		priv->mac_control |= CMD_ACT_MAC_PROMISCUOUS_ENABLE;
		priv->mac_control &= ~(CMD_ACT_MAC_ALL_MULTICAST_ENABLE |
				       CMD_ACT_MAC_MULTICAST_ENABLE);
		goto out_set_mac_control;
	} else if (dev_flags & IFF_ALLMULTI) {
	do_allmulti:
		priv->mac_control |= CMD_ACT_MAC_ALL_MULTICAST_ENABLE;
		priv->mac_control &= ~(CMD_ACT_MAC_PROMISCUOUS_ENABLE |
				       CMD_ACT_MAC_MULTICAST_ENABLE);
		goto out_set_mac_control;
286 287
	}

288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311
	/* Once for priv->dev, again for priv->mesh_dev if it exists */
	nr_addrs = lbs_add_mcast_addrs(&mcast_cmd, priv->dev, 0);
	if (nr_addrs >= 0 && priv->mesh_dev)
		nr_addrs = lbs_add_mcast_addrs(&mcast_cmd, priv->mesh_dev, nr_addrs);
	if (nr_addrs < 0)
		goto do_allmulti;

	if (nr_addrs) {
		int size = offsetof(struct cmd_ds_mac_multicast_adr,
				    maclist[6*nr_addrs]);

		mcast_cmd.action = cpu_to_le16(CMD_ACT_SET);
		mcast_cmd.hdr.size = cpu_to_le16(size);
		mcast_cmd.nr_of_adrs = cpu_to_le16(nr_addrs);

		lbs_cmd_async(priv, CMD_MAC_MULTICAST_ADR, &mcast_cmd.hdr, size);

		priv->mac_control |= CMD_ACT_MAC_MULTICAST_ENABLE;
	} else
		priv->mac_control &= ~CMD_ACT_MAC_MULTICAST_ENABLE;

	priv->mac_control &= ~(CMD_ACT_MAC_PROMISCUOUS_ENABLE |
			       CMD_ACT_MAC_ALL_MULTICAST_ENABLE);
 out_set_mac_control:
312 313
	if (priv->mac_control != old_mac_control)
		lbs_set_mac_control(priv);
314

315
	lbs_deb_leave(LBS_DEB_NET);
316 317
}

318
void lbs_set_multicast_list(struct net_device *dev)
319
{
320
	struct lbs_private *priv = dev->ml_priv;
321 322 323 324

	schedule_work(&priv->mcast_work);
}

325
/**
326
 *  lbs_thread - handles the major jobs in the LBS driver.
327 328
 *  It handles all events generated by firmware, RX data received
 *  from firmware and TX data sent from kernel.
329
 *
330 331
 *  @data:	A pointer to &lbs_thread structure
 *  returns:	0
332
 */
333
static int lbs_thread(void *data)
334
{
335
	struct net_device *dev = data;
336
	struct lbs_private *priv = dev->ml_priv;
337 338
	wait_queue_t wait;

339
	lbs_deb_enter(LBS_DEB_THREAD);
340 341 342 343

	init_waitqueue_entry(&wait, current);

	for (;;) {
344
		int shouldsleep;
345
		u8 resp_idx;
346

347 348
		lbs_deb_thread("1: currenttxskb %p, dnld_sent %d\n",
				priv->currenttxskb, priv->dnld_sent);
349

350
		add_wait_queue(&priv->waitq, &wait);
351
		set_current_state(TASK_INTERRUPTIBLE);
352
		spin_lock_irq(&priv->driver_lock);
353

354
		if (kthread_should_stop())
355
			shouldsleep = 0;	/* Bye */
356 357
		else if (priv->surpriseremoved)
			shouldsleep = 1;	/* We need to wait until we're _told_ to die */
358 359
		else if (priv->psstate == PS_STATE_SLEEP)
			shouldsleep = 1;	/* Sleep mode. Nothing we can do till it wakes */
360 361
		else if (priv->cmd_timed_out)
			shouldsleep = 0;	/* Command timed out. Recover */
362 363
		else if (!priv->fw_ready)
			shouldsleep = 1;	/* Firmware not ready. We're waiting for it */
364 365
		else if (priv->dnld_sent)
			shouldsleep = 1;	/* Something is en route to the device already */
366 367
		else if (priv->tx_pending_len > 0)
			shouldsleep = 0;	/* We've a packet to send */
368 369
		else if (priv->resp_len[priv->resp_idx])
			shouldsleep = 0;	/* We have a command response */
370 371
		else if (priv->cur_cmd)
			shouldsleep = 1;	/* Can't send a command; one already running */
372 373
		else if (!list_empty(&priv->cmdpendingq) &&
					!(priv->wakeup_dev_required))
374
			shouldsleep = 0;	/* We have a command to send */
S
Stefani Seibold 已提交
375
		else if (kfifo_len(&priv->event_fifo))
376
			shouldsleep = 0;	/* We have an event to process */
377 378 379 380
		else
			shouldsleep = 1;	/* No command */

		if (shouldsleep) {
381
			lbs_deb_thread("sleeping, connect_status %d, "
382
				"psmode %d, psstate %d\n",
383 384
				priv->connect_status,
				priv->psmode, priv->psstate);
385
			spin_unlock_irq(&priv->driver_lock);
386 387
			schedule();
		} else
388
			spin_unlock_irq(&priv->driver_lock);
389

390 391
		lbs_deb_thread("2: currenttxskb %p, dnld_send %d\n",
			       priv->currenttxskb, priv->dnld_sent);
392 393

		set_current_state(TASK_RUNNING);
394
		remove_wait_queue(&priv->waitq, &wait);
395

396 397
		lbs_deb_thread("3: currenttxskb %p, dnld_sent %d\n",
			       priv->currenttxskb, priv->dnld_sent);
398

399
		if (kthread_should_stop()) {
400
			lbs_deb_thread("break from main thread\n");
401 402 403
			break;
		}

404 405 406 407
		if (priv->surpriseremoved) {
			lbs_deb_thread("adapter removed; waiting to die...\n");
			continue;
		}
408

409 410
		lbs_deb_thread("4: currenttxskb %p, dnld_sent %d\n",
		       priv->currenttxskb, priv->dnld_sent);
411

412
		/* Process any pending command response */
413
		spin_lock_irq(&priv->driver_lock);
414 415
		resp_idx = priv->resp_idx;
		if (priv->resp_len[resp_idx]) {
416
			spin_unlock_irq(&priv->driver_lock);
417 418 419
			lbs_process_command_response(priv,
				priv->resp_buf[resp_idx],
				priv->resp_len[resp_idx]);
420
			spin_lock_irq(&priv->driver_lock);
421
			priv->resp_len[resp_idx] = 0;
422
		}
423
		spin_unlock_irq(&priv->driver_lock);
424

425 426
		/* Process hardware events, e.g. card removed, link lost */
		spin_lock_irq(&priv->driver_lock);
S
Stefani Seibold 已提交
427
		while (kfifo_len(&priv->event_fifo)) {
428
			u32 event;
429

S
Stefani Seibold 已提交
430 431 432 433
			if (kfifo_out(&priv->event_fifo,
				(unsigned char *) &event, sizeof(event)) !=
				sizeof(event))
					break;
434 435 436 437 438 439 440 441 442 443 444 445 446 447
			spin_unlock_irq(&priv->driver_lock);
			lbs_process_event(priv, event);
			spin_lock_irq(&priv->driver_lock);
		}
		spin_unlock_irq(&priv->driver_lock);

		if (priv->wakeup_dev_required) {
			lbs_deb_thread("Waking up device...\n");
			/* Wake up device */
			if (priv->exit_deep_sleep(priv))
				lbs_deb_thread("Wakeup device failed\n");
			continue;
		}

448
		/* command timeout stuff */
449 450 451
		if (priv->cmd_timed_out && priv->cur_cmd) {
			struct cmd_ctrl_node *cmdnode = priv->cur_cmd;

452 453
			netdev_info(dev, "Timeout submitting command 0x%04x\n",
				    le16_to_cpu(cmdnode->cmdbuf->command));
H
Holger Schurig 已提交
454 455 456
			lbs_complete_command(priv, cmdnode, -ETIMEDOUT);
			if (priv->reset_card)
				priv->reset_card(priv);
457 458 459
		}
		priv->cmd_timed_out = 0;

460 461 462
		if (!priv->fw_ready)
			continue;

463
		/* Check if we need to confirm Sleep Request received previously */
464 465 466
		if (priv->psstate == PS_STATE_PRE_SLEEP &&
		    !priv->dnld_sent && !priv->cur_cmd) {
			if (priv->connect_status == LBS_CONNECTED) {
467 468 469 470
				lbs_deb_thread("pre-sleep, currenttxskb %p, "
					"dnld_sent %d, cur_cmd %p\n",
					priv->currenttxskb, priv->dnld_sent,
					priv->cur_cmd);
471

472
				lbs_ps_confirm_sleep(priv);
473 474 475 476 477 478
			} else {
				/* workaround for firmware sending
				 * deauth/linkloss event immediately
				 * after sleep request; remove this
				 * after firmware fixes it
				 */
479
				priv->psstate = PS_STATE_AWAKE;
480 481
				netdev_alert(dev,
					     "ignore PS_SleepConfirm in non-connected state\n");
482 483 484 485 486 487
			}
		}

		/* The PS state is changed during processing of Sleep Request
		 * event above
		 */
488 489
		if ((priv->psstate == PS_STATE_SLEEP) ||
		    (priv->psstate == PS_STATE_PRE_SLEEP))
490 491
			continue;

492 493 494
		if (priv->is_deep_sleep)
			continue;

495
		/* Execute the next command */
496
		if (!priv->dnld_sent && !priv->cur_cmd)
497
			lbs_execute_next_command(priv);
498

499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514
		spin_lock_irq(&priv->driver_lock);
		if (!priv->dnld_sent && priv->tx_pending_len > 0) {
			int ret = priv->hw_host_to_card(priv, MVMS_DAT,
							priv->tx_pending_buf,
							priv->tx_pending_len);
			if (ret) {
				lbs_deb_tx("host_to_card failed %d\n", ret);
				priv->dnld_sent = DNLD_RES_RECEIVED;
			}
			priv->tx_pending_len = 0;
			if (!priv->currenttxskb) {
				/* We can wake the queues immediately if we aren't
				   waiting for TX feedback */
				if (priv->connect_status == LBS_CONNECTED)
					netif_wake_queue(priv->dev);
				if (priv->mesh_dev &&
515
				    lbs_mesh_connected(priv))
516 517 518 519
					netif_wake_queue(priv->mesh_dev);
			}
		}
		spin_unlock_irq(&priv->driver_lock);
520 521
	}

522
	del_timer(&priv->command_timer);
523
	del_timer(&priv->auto_deepsleep_timer);
524

525
	lbs_deb_leave(LBS_DEB_THREAD);
526 527 528
	return 0;
}

529
/**
530 531
 * lbs_setup_firmware - gets the HW spec from the firmware and sets
 *        some basic parameters
532
 *
533 534
 *  @priv:	A pointer to &struct lbs_private structure
 *  returns:	0 or -1
535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565
 */
static int lbs_setup_firmware(struct lbs_private *priv)
{
	int ret = -1;
	s16 curlevel = 0, minlevel = 0, maxlevel = 0;

	lbs_deb_enter(LBS_DEB_FW);

	/* Read MAC address from firmware */
	memset(priv->current_addr, 0xff, ETH_ALEN);
	ret = lbs_update_hw_spec(priv);
	if (ret)
		goto done;

	/* Read power levels if available */
	ret = lbs_get_tx_power(priv, &curlevel, &minlevel, &maxlevel);
	if (ret == 0) {
		priv->txpower_cur = curlevel;
		priv->txpower_min = minlevel;
		priv->txpower_max = maxlevel;
	}

	/* Send cmd to FW to enable 11D function */
	ret = lbs_set_snmp_mib(priv, SNMP_MIB_OID_11D_ENABLE, 1);

	lbs_set_mac_control(priv);
done:
	lbs_deb_leave_args(LBS_DEB_FW, "ret %d", ret);
	return ret;
}

566 567 568 569
int lbs_suspend(struct lbs_private *priv)
{
	int ret;

570 571
	lbs_deb_enter(LBS_DEB_FW);

572 573 574
	if (priv->is_deep_sleep) {
		ret = lbs_set_deep_sleep(priv, 0);
		if (ret) {
575 576
			netdev_err(priv->dev,
				   "deep sleep cancellation failed: %d\n", ret);
577 578 579
			return ret;
		}
		priv->deep_sleep_required = 1;
580 581
	}

582
	ret = lbs_set_host_sleep(priv, 1);
583

584 585 586
	netif_device_detach(priv->dev);
	if (priv->mesh_dev)
		netif_device_detach(priv->mesh_dev);
587

588
	lbs_deb_leave_args(LBS_DEB_FW, "ret %d", ret);
589 590 591 592
	return ret;
}
EXPORT_SYMBOL_GPL(lbs_suspend);

593
int lbs_resume(struct lbs_private *priv)
594
{
595
	int ret;
596

597
	lbs_deb_enter(LBS_DEB_FW);
598

599
	ret = lbs_set_host_sleep(priv, 0);
600 601 602 603 604

	netif_device_attach(priv->dev);
	if (priv->mesh_dev)
		netif_device_attach(priv->mesh_dev);

605 606 607 608
	if (priv->deep_sleep_required) {
		priv->deep_sleep_required = 0;
		ret = lbs_set_deep_sleep(priv, 1);
		if (ret)
609 610
			netdev_err(priv->dev,
				   "deep sleep activation failed: %d\n", ret);
611 612
	}

613 614
	if (priv->setup_fw_on_resume)
		ret = lbs_setup_firmware(priv);
615

H
Holger Schurig 已提交
616 617 618
	lbs_deb_leave_args(LBS_DEB_FW, "ret %d", ret);
	return ret;
}
619
EXPORT_SYMBOL_GPL(lbs_resume);
H
Holger Schurig 已提交
620 621

/**
622 623 624 625
 * lbs_cmd_timeout_handler - handles the timeout of command sending.
 * It will re-send the same command again.
 *
 * @data: &struct lbs_private pointer
H
Holger Schurig 已提交
626
 */
H
Holger Schurig 已提交
627
static void lbs_cmd_timeout_handler(unsigned long data)
H
Holger Schurig 已提交
628
{
629
	struct lbs_private *priv = (struct lbs_private *)data;
H
Holger Schurig 已提交
630 631
	unsigned long flags;

632
	lbs_deb_enter(LBS_DEB_CMD);
633
	spin_lock_irqsave(&priv->driver_lock, flags);
H
Holger Schurig 已提交
634

635
	if (!priv->cur_cmd)
636
		goto out;
H
Holger Schurig 已提交
637

638 639
	netdev_info(priv->dev, "command 0x%04x timed out\n",
		    le16_to_cpu(priv->cur_cmd->cmdbuf->command));
H
Holger Schurig 已提交
640

641
	priv->cmd_timed_out = 1;
H
Holger Schurig 已提交
642
	wake_up_interruptible(&priv->waitq);
643
out:
644
	spin_unlock_irqrestore(&priv->driver_lock, flags);
645
	lbs_deb_leave(LBS_DEB_CMD);
H
Holger Schurig 已提交
646 647
}

648
/**
649 650 651 652
 * auto_deepsleep_timer_fn - put the device back to deep sleep mode when
 * timer expires and no activity (command, event, data etc.) is detected.
 * @data:	&struct lbs_private pointer
 * returns:	N/A
653 654 655 656 657 658 659 660 661 662 663
 */
static void auto_deepsleep_timer_fn(unsigned long data)
{
	struct lbs_private *priv = (struct lbs_private *)data;

	lbs_deb_enter(LBS_DEB_CMD);

	if (priv->is_activity_detected) {
		priv->is_activity_detected = 0;
	} else {
		if (priv->is_auto_deep_sleep_enabled &&
664 665 666 667
		    (!priv->wakeup_dev_required) &&
		    (priv->connect_status != LBS_CONNECTED)) {
			struct cmd_header cmd;

668
			lbs_deb_main("Entering auto deep sleep mode...\n");
669 670 671 672
			memset(&cmd, 0, sizeof(cmd));
			cmd.size = cpu_to_le16(sizeof(cmd));
			lbs_cmd_async(priv, CMD_802_11_DEEP_SLEEP, &cmd,
					sizeof(cmd));
673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705
		}
	}
	mod_timer(&priv->auto_deepsleep_timer , jiffies +
				(priv->auto_deep_sleep_timeout * HZ)/1000);
	lbs_deb_leave(LBS_DEB_CMD);
}

int lbs_enter_auto_deep_sleep(struct lbs_private *priv)
{
	lbs_deb_enter(LBS_DEB_SDIO);

	priv->is_auto_deep_sleep_enabled = 1;
	if (priv->is_deep_sleep)
		priv->wakeup_dev_required = 1;
	mod_timer(&priv->auto_deepsleep_timer ,
			jiffies + (priv->auto_deep_sleep_timeout * HZ)/1000);

	lbs_deb_leave(LBS_DEB_SDIO);
	return 0;
}

int lbs_exit_auto_deep_sleep(struct lbs_private *priv)
{
	lbs_deb_enter(LBS_DEB_SDIO);

	priv->is_auto_deep_sleep_enabled = 0;
	priv->auto_deep_sleep_timeout = 0;
	del_timer(&priv->auto_deepsleep_timer);

	lbs_deb_leave(LBS_DEB_SDIO);
	return 0;
}

706
static int lbs_init_adapter(struct lbs_private *priv)
707
{
K
Kiran Divekar 已提交
708
	int ret;
H
Holger Schurig 已提交
709

710 711
	lbs_deb_enter(LBS_DEB_MAIN);

712
	memset(priv->current_addr, 0xff, ETH_ALEN);
H
Holger Schurig 已提交
713

714
	priv->connect_status = LBS_DISCONNECTED;
715
	priv->channel = DEFAULT_AD_HOC_CHANNEL;
716
	priv->mac_control = CMD_ACT_MAC_RX_ON | CMD_ACT_MAC_TX_ON;
717
	priv->radio_on = 1;
718 719
	priv->psmode = LBS802_11POWERMODECAM;
	priv->psstate = PS_STATE_FULL_POWER;
720 721
	priv->is_deep_sleep = 0;
	priv->is_auto_deep_sleep_enabled = 0;
722
	priv->deep_sleep_required = 0;
723 724
	priv->wakeup_dev_required = 0;
	init_waitqueue_head(&priv->ds_awake_q);
725
	init_waitqueue_head(&priv->scan_q);
726
	priv->authtype_auto = 1;
727 728 729
	priv->is_host_sleep_configured = 0;
	priv->is_host_sleep_activated = 0;
	init_waitqueue_head(&priv->host_sleep_q);
730
	mutex_init(&priv->lock);
H
Holger Schurig 已提交
731

H
Holger Schurig 已提交
732
	setup_timer(&priv->command_timer, lbs_cmd_timeout_handler,
733
		(unsigned long)priv);
734 735
	setup_timer(&priv->auto_deepsleep_timer, auto_deepsleep_timer_fn,
			(unsigned long)priv);
H
Holger Schurig 已提交
736

737 738
	INIT_LIST_HEAD(&priv->cmdfreeq);
	INIT_LIST_HEAD(&priv->cmdpendingq);
H
Holger Schurig 已提交
739

740
	spin_lock_init(&priv->driver_lock);
H
Holger Schurig 已提交
741

742
	/* Allocate the command buffers */
743
	if (lbs_allocate_cmd_buffer(priv)) {
744
		pr_err("Out of memory allocating command buffers\n");
745 746 747 748 749 750 751
		ret = -ENOMEM;
		goto out;
	}
	priv->resp_idx = 0;
	priv->resp_len[0] = priv->resp_len[1] = 0;

	/* Create the event FIFO */
S
Stefani Seibold 已提交
752
	ret = kfifo_alloc(&priv->event_fifo, sizeof(u32) * 16, GFP_KERNEL);
753
	if (ret) {
754
		pr_err("Out of memory allocating event FIFO buffer\n");
755
		goto out;
756
	}
H
Holger Schurig 已提交
757

758
out:
759 760
	lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret);

761 762
	return ret;
}
H
Holger Schurig 已提交
763

764
static void lbs_free_adapter(struct lbs_private *priv)
765
{
766
	lbs_deb_enter(LBS_DEB_MAIN);
H
Holger Schurig 已提交
767

768
	lbs_free_cmd_buffer(priv);
769
	kfifo_free(&priv->event_fifo);
770
	del_timer(&priv->command_timer);
771
	del_timer(&priv->auto_deepsleep_timer);
772 773

	lbs_deb_leave(LBS_DEB_MAIN);
H
Holger Schurig 已提交
774 775
}

776 777 778 779 780 781 782 783 784 785
static const struct net_device_ops lbs_netdev_ops = {
	.ndo_open 		= lbs_dev_open,
	.ndo_stop		= lbs_eth_stop,
	.ndo_start_xmit		= lbs_hard_start_xmit,
	.ndo_set_mac_address	= lbs_set_mac_address,
	.ndo_set_multicast_list = lbs_set_multicast_list,
	.ndo_change_mtu		= eth_change_mtu,
	.ndo_validate_addr	= eth_validate_addr,
};

786
/**
787
 * lbs_add_card - adds the card. It will probe the
788
 * card, allocate the lbs_priv and initialize the device.
789
 *
790 791 792
 * @card:	A pointer to card
 * @dmdev:	A pointer to &struct device
 * returns:	A pointer to &struct lbs_private structure
793
 */
794
struct lbs_private *lbs_add_card(void *card, struct device *dmdev)
795
{
796 797
	struct net_device *dev;
	struct wireless_dev *wdev;
798
	struct lbs_private *priv = NULL;
799

800
	lbs_deb_enter(LBS_DEB_MAIN);
801 802

	/* Allocate an Ethernet device and register it */
803 804
	wdev = lbs_cfg_alloc(dmdev);
	if (IS_ERR(wdev)) {
805
		pr_err("cfg80211 init failed\n");
806
		goto done;
807
	}
K
Kiran Divekar 已提交
808

809 810 811
	wdev->iftype = NL80211_IFTYPE_STATION;
	priv = wdev_priv(wdev);
	priv->wdev = wdev;
812

813
	if (lbs_init_adapter(priv)) {
814
		pr_err("failed to initialize adapter structure\n");
815 816 817 818 819 820 821
		goto err_wdev;
	}

	dev = alloc_netdev(0, "wlan%d", ether_setup);
	if (!dev) {
		dev_err(dmdev, "no memory for network device instance\n");
		goto err_adapter;
822 823
	}

824 825 826 827
	dev->ieee80211_ptr = wdev;
	dev->ml_priv = priv;
	SET_NETDEV_DEV(dev, dmdev);
	wdev->netdev = dev;
828
	priv->dev = dev;
829

830
 	dev->netdev_ops = &lbs_netdev_ops;
831
	dev->watchdog_timeo = 5 * HZ;
832
	dev->ethtool_ops = &lbs_ethtool_ops;
833 834
	dev->flags |= IFF_BROADCAST | IFF_MULTICAST;

835
	priv->card = card;
836

837
	strcpy(dev->name, "wlan%d");
838 839 840

	lbs_deb_thread("Starting main thread...\n");
	init_waitqueue_head(&priv->waitq);
841
	priv->main_thread = kthread_run(lbs_thread, dev, "lbs_main");
842 843
	if (IS_ERR(priv->main_thread)) {
		lbs_deb_thread("Error creating main thread.\n");
844
		goto err_ndev;
845 846
	}

847
	priv->work_thread = create_singlethread_workqueue("lbs_worker");
848
	INIT_WORK(&priv->mcast_work, lbs_set_mcast_worker);
849

850
	priv->wol_criteria = EHS_REMOVE_WAKEUP;
851
	priv->wol_gpio = 0xff;
852
	priv->wol_gap = 20;
853
	priv->ehs_remove_supported = true;
854

855 856
	goto done;

857
 err_ndev:
858
	free_netdev(dev);
859 860 861 862 863 864 865

 err_adapter:
	lbs_free_adapter(priv);

 err_wdev:
	lbs_cfg_free(priv);

866
	priv = NULL;
867

868
done:
869
	lbs_deb_leave_args(LBS_DEB_MAIN, "priv %p", priv);
870 871
	return priv;
}
872
EXPORT_SYMBOL_GPL(lbs_add_card);
873

874

875
void lbs_remove_card(struct lbs_private *priv)
876
{
877
	struct net_device *dev = priv->dev;
878 879

	lbs_deb_enter(LBS_DEB_MAIN);
880

881
	lbs_remove_mesh(priv);
K
Kiran Divekar 已提交
882
	lbs_scan_deinit(priv);
883

884
	dev = priv->dev;
885

886
	cancel_work_sync(&priv->mcast_work);
887 888 889 890 891

	/* worker thread destruction blocks on the in-flight command which
	 * should have been cleared already in lbs_stop_card().
	 */
	lbs_deb_main("destroying worker thread\n");
892
	destroy_workqueue(priv->work_thread);
893
	lbs_deb_main("done destroying worker thread\n");
894

895 896
	if (priv->psmode == LBS802_11POWERMODEMAX_PSP) {
		priv->psmode = LBS802_11POWERMODECAM;
897
		lbs_set_ps_mode(priv, PS_MODE_ACTION_EXIT_PS, true);
898 899
	}

900 901 902 903 904
	if (priv->is_deep_sleep) {
		priv->is_deep_sleep = 0;
		wake_up_interruptible(&priv->ds_awake_q);
	}

905 906 907 908
	priv->is_host_sleep_configured = 0;
	priv->is_host_sleep_activated = 0;
	wake_up_interruptible(&priv->host_sleep_q);

909
	/* Stop the thread servicing the interrupts */
910
	priv->surpriseremoved = 1;
911 912
	kthread_stop(priv->main_thread);

913
	lbs_free_adapter(priv);
914
	lbs_cfg_free(priv);
915 916 917 918
	free_netdev(dev);

	lbs_deb_leave(LBS_DEB_MAIN);
}
919
EXPORT_SYMBOL_GPL(lbs_remove_card);
920 921


K
Kiran Divekar 已提交
922
int lbs_rtap_supported(struct lbs_private *priv)
H
Holger Schurig 已提交
923 924 925 926 927 928 929 930 931 932
{
	if (MRVL_FW_MAJOR_REV(priv->fwrelease) == MRVL_FW_V5)
		return 1;

	/* newer firmware use a capability mask */
	return ((MRVL_FW_MAJOR_REV(priv->fwrelease) >= MRVL_FW_V10) &&
		(priv->fwcapinfo & MESH_CAPINFO_ENABLE_MASK));
}


933
int lbs_start_card(struct lbs_private *priv)
934 935 936 937 938 939 940
{
	struct net_device *dev = priv->dev;
	int ret = -1;

	lbs_deb_enter(LBS_DEB_MAIN);

	/* poke the firmware */
941
	ret = lbs_setup_firmware(priv);
942 943 944
	if (ret)
		goto done;

945
	if (lbs_cfg_register(priv)) {
946
		pr_err("cannot register device\n");
947
		goto done;
948
	}
949 950 951

	lbs_update_channel(priv);

952 953 954 955
	if (!lbs_disablemesh)
		lbs_init_mesh(priv);
	else
		pr_info("%s: mesh disabled\n", dev->name);
H
Holger Schurig 已提交
956

957
	lbs_debugfs_init_one(priv, dev);
958

959
	netdev_info(dev, "Marvell WLAN 802.11 adapter\n");
960

961
	ret = 0;
962

963
done:
964 965 966
	lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret);
	return ret;
}
967
EXPORT_SYMBOL_GPL(lbs_start_card);
968 969


970
void lbs_stop_card(struct lbs_private *priv)
971
{
972
	struct net_device *dev;
973 974 975 976 977
	struct cmd_ctrl_node *cmdnode;
	unsigned long flags;

	lbs_deb_enter(LBS_DEB_MAIN);

978 979
	if (!priv)
		goto out;
980
	dev = priv->dev;
981

982 983
	netif_stop_queue(dev);
	netif_carrier_off(dev);
984

985
	lbs_debugfs_remove_one(priv);
H
Holger Schurig 已提交
986 987
	lbs_deinit_mesh(priv);

988
	/* Delete the timeout of the currently processing command */
989
	del_timer_sync(&priv->command_timer);
990
	del_timer_sync(&priv->auto_deepsleep_timer);
991 992

	/* Flush pending command nodes */
993
	spin_lock_irqsave(&priv->driver_lock, flags);
994
	lbs_deb_main("clearing pending commands\n");
995
	list_for_each_entry(cmdnode, &priv->cmdpendingq, list) {
996
		cmdnode->result = -ENOENT;
997 998 999
		cmdnode->cmdwaitqwoken = 1;
		wake_up_interruptible(&cmdnode->cmdwait_q);
	}
1000 1001 1002 1003 1004 1005 1006 1007 1008

	/* Flush the command the card is currently processing */
	if (priv->cur_cmd) {
		lbs_deb_main("clearing current command\n");
		priv->cur_cmd->result = -ENOENT;
		priv->cur_cmd->cmdwaitqwoken = 1;
		wake_up_interruptible(&priv->cur_cmd->cmdwait_q);
	}
	lbs_deb_main("done clearing commands\n");
1009
	spin_unlock_irqrestore(&priv->driver_lock, flags);
1010 1011 1012

	unregister_netdev(dev);

1013
out:
1014
	lbs_deb_leave(LBS_DEB_MAIN);
1015
}
1016
EXPORT_SYMBOL_GPL(lbs_stop_card);
1017

1018

1019 1020 1021 1022 1023 1024 1025 1026 1027 1028
void lbs_queue_event(struct lbs_private *priv, u32 event)
{
	unsigned long flags;

	lbs_deb_enter(LBS_DEB_THREAD);
	spin_lock_irqsave(&priv->driver_lock, flags);

	if (priv->psstate == PS_STATE_SLEEP)
		priv->psstate = PS_STATE_AWAKE;

1029
	kfifo_in(&priv->event_fifo, (unsigned char *) &event, sizeof(u32));
1030 1031 1032 1033 1034 1035 1036 1037 1038

	wake_up_interruptible(&priv->waitq);

	spin_unlock_irqrestore(&priv->driver_lock, flags);
	lbs_deb_leave(LBS_DEB_THREAD);
}
EXPORT_SYMBOL_GPL(lbs_queue_event);

void lbs_notify_command_response(struct lbs_private *priv, u8 resp_idx)
1039
{
1040
	lbs_deb_enter(LBS_DEB_THREAD);
1041

1042
	if (priv->psstate == PS_STATE_SLEEP)
1043
		priv->psstate = PS_STATE_AWAKE;
1044 1045 1046 1047 1048

	/* Swap buffers by flipping the response index */
	BUG_ON(resp_idx > 1);
	priv->resp_idx = resp_idx;

1049
	wake_up_interruptible(&priv->waitq);
1050

1051
	lbs_deb_leave(LBS_DEB_THREAD);
1052
}
1053
EXPORT_SYMBOL_GPL(lbs_notify_command_response);
1054

1055
/**
1056
 *  lbs_get_firmware - Retrieves two-stage firmware
1057
 *
1058 1059 1060 1061 1062 1063 1064 1065 1066
 *  @dev:     	A pointer to &device structure
 *  @user_helper: User-defined helper firmware file
 *  @user_mainfw: User-defined main firmware file
 *  @card_model: Bus-specific card model ID used to filter firmware table
 *		elements
 *  @fw_table:	Table of firmware file names and device model numbers
 *		terminated by an entry with a NULL helper name
 *  @helper:	On success, the helper firmware; caller must free
 *  @mainfw:	On success, the main firmware; caller must free
1067
 *
1068
 *  returns:		0 on success, non-zero on failure
1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085
 */
int lbs_get_firmware(struct device *dev, const char *user_helper,
			const char *user_mainfw, u32 card_model,
			const struct lbs_fw_table *fw_table,
			const struct firmware **helper,
			const struct firmware **mainfw)
{
	const struct lbs_fw_table *iter;
	int ret;

	BUG_ON(helper == NULL);
	BUG_ON(mainfw == NULL);

	/* Try user-specified firmware first */
	if (user_helper) {
		ret = request_firmware(helper, user_helper, dev);
		if (ret) {
1086 1087
			dev_err(dev, "couldn't find helper firmware %s\n",
				user_helper);
1088 1089 1090 1091 1092 1093
			goto fail;
		}
	}
	if (user_mainfw) {
		ret = request_firmware(mainfw, user_mainfw, dev);
		if (ret) {
1094 1095
			dev_err(dev, "couldn't find main firmware %s\n",
				user_mainfw);
1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159
			goto fail;
		}
	}

	if (*helper && *mainfw)
		return 0;

	/* Otherwise search for firmware to use.  If neither the helper or
	 * the main firmware were specified by the user, then we need to
	 * make sure that found helper & main are from the same entry in
	 * fw_table.
	 */
	iter = fw_table;
	while (iter && iter->helper) {
		if (iter->model != card_model)
			goto next;

		if (*helper == NULL) {
			ret = request_firmware(helper, iter->helper, dev);
			if (ret)
				goto next;

			/* If the device has one-stage firmware (ie cf8305) and
			 * we've got it then we don't need to bother with the
			 * main firmware.
			 */
			if (iter->fwname == NULL)
				return 0;
		}

		if (*mainfw == NULL) {
			ret = request_firmware(mainfw, iter->fwname, dev);
			if (ret && !user_helper) {
				/* Clear the helper if it wasn't user-specified
				 * and the main firmware load failed, to ensure
				 * we don't have mismatched firmware pairs.
				 */
				release_firmware(*helper);
				*helper = NULL;
			}
		}

		if (*helper && *mainfw)
			return 0;

  next:
		iter++;
	}

  fail:
	/* Failed */
	if (*helper) {
		release_firmware(*helper);
		*helper = NULL;
	}
	if (*mainfw) {
		release_firmware(*mainfw);
		*mainfw = NULL;
	}

	return -ENOENT;
}
EXPORT_SYMBOL_GPL(lbs_get_firmware);

1160
static int __init lbs_init_module(void)
1161
{
1162
	lbs_deb_enter(LBS_DEB_MAIN);
1163 1164 1165
	memset(&confirm_sleep, 0, sizeof(confirm_sleep));
	confirm_sleep.hdr.command = cpu_to_le16(CMD_802_11_PS_MODE);
	confirm_sleep.hdr.size = cpu_to_le16(sizeof(confirm_sleep));
1166
	confirm_sleep.action = cpu_to_le16(PS_MODE_ACTION_SLEEP_CONFIRMED);
1167
	lbs_debugfs_init();
1168 1169
	lbs_deb_leave(LBS_DEB_MAIN);
	return 0;
1170 1171
}

1172
static void __exit lbs_exit_module(void)
1173
{
1174
	lbs_deb_enter(LBS_DEB_MAIN);
1175
	lbs_debugfs_remove();
1176
	lbs_deb_leave(LBS_DEB_MAIN);
1177 1178
}

1179 1180
module_init(lbs_init_module);
module_exit(lbs_exit_module);
1181

1182
MODULE_DESCRIPTION("Libertas WLAN Driver Library");
1183 1184
MODULE_AUTHOR("Marvell International Ltd.");
MODULE_LICENSE("GPL");