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