projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge remote-tracking branches 'regulator/fix/doc', 'regulator/fix/max77686' and...
[deliverable/linux.git] / drivers / net / wireless / ath / ath9k / hif_usb.c
CommitLineData
fb9987d0 1/*
5b68138e 2 * Copyright (c) 2010-2011 Atheros Communications Inc.
fb9987d0
S		 3 *
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15 */
16
78fa99ab 17#include <asm/unaligned.h>
fb9987d0
S		 18#include "htc.h"
19
d0ee0ebe 20/* identify firmware images */
ce18f391
SM		 21#define FIRMWARE_AR7010_1_1 "htc_7010.fw"
22#define FIRMWARE_AR9271 "htc_9271.fw"
d0ee0ebe 23
d0ee0ebe
JL		 24MODULE_FIRMWARE(FIRMWARE_AR7010_1_1);
25MODULE_FIRMWARE(FIRMWARE_AR9271);
26
fb9987d0 27static struct usb_device_id ath9k_hif_usb_ids[] = {
4e63f768
S		 28 { USB_DEVICE(0x0cf3, 0x9271) }, /* Atheros */
29 { USB_DEVICE(0x0cf3, 0x1006) }, /* Atheros */
4e63f768 30 { USB_DEVICE(0x0846, 0x9030) }, /* Netgear N150 */
4e63f768
S		 31 { USB_DEVICE(0x07D1, 0x3A10) }, /* Dlink Wireless 150 */
32 { USB_DEVICE(0x13D3, 0x3327) }, /* Azurewave */
33 { USB_DEVICE(0x13D3, 0x3328) }, /* Azurewave */
ac618d70 34 { USB_DEVICE(0x13D3, 0x3346) }, /* IMC Networks */
32b08955
RM		 35 { USB_DEVICE(0x13D3, 0x3348) }, /* Azurewave */
36 { USB_DEVICE(0x13D3, 0x3349) }, /* Azurewave */
37 { USB_DEVICE(0x13D3, 0x3350) }, /* Azurewave */
4e63f768 38 { USB_DEVICE(0x04CA, 0x4605) }, /* Liteon */
32b08955 39 { USB_DEVICE(0x040D, 0x3801) }, /* VIA */
452d7dd8 40 { USB_DEVICE(0x0cf3, 0xb003) }, /* Ubiquiti WifiStation Ext */
763cbac0 41 { USB_DEVICE(0x0cf3, 0xb002) }, /* Ubiquiti WifiStation */
8c34559b 42 { USB_DEVICE(0x057c, 0x8403) }, /* AVM FRITZ!WLAN 11N v2 USB */
0088d27b 43 { USB_DEVICE(0x0471, 0x209e) }, /* Philips (or NXP) PTA01 */
0b5ead91
SM		 44
45 { USB_DEVICE(0x0cf3, 0x7015),
46 .driver_info = AR9287_USB }, /* Atheros */
64f12170 47 { USB_DEVICE(0x1668, 0x1200),
0b5ead91
SM		 48 .driver_info = AR9287_USB }, /* Verizon */
49
50 { USB_DEVICE(0x0cf3, 0x7010),
51 .driver_info = AR9280_USB }, /* Atheros */
52 { USB_DEVICE(0x0846, 0x9018),
53 .driver_info = AR9280_USB }, /* Netgear WNDA3200 */
54 { USB_DEVICE(0x083A, 0xA704),
55 .driver_info = AR9280_USB }, /* SMC Networks */
5cf6fa78
MSS		 56 { USB_DEVICE(0x0411, 0x017f),
57 .driver_info = AR9280_USB }, /* Sony UWA-BR100 */
98f99eea
MT		 58 { USB_DEVICE(0x0411, 0x0197),
59 .driver_info = AR9280_USB }, /* Buffalo WLI-UV-AG300P */
d90b5708
SM		 60 { USB_DEVICE(0x04da, 0x3904),
61 .driver_info = AR9280_USB },
0b5ead91 62
36bcce43
SM		 63 { USB_DEVICE(0x0cf3, 0x20ff),
64 .driver_info = STORAGE_DEVICE },
65
fb9987d0
S		 66 { },
67};
68
69MODULE_DEVICE_TABLE(usb, ath9k_hif_usb_ids);
70
71static int __hif_usb_tx(struct hif_device_usb *hif_dev);
72
73static void hif_usb_regout_cb(struct urb *urb)
74{
75 struct cmd_buf *cmd = (struct cmd_buf *)urb->context;
fb9987d0
S		 76
77 switch (urb->status) {
78 case 0:
79 break;
80 case -ENOENT:
81 case -ECONNRESET:
fb9987d0
S		 82 case -ENODEV:
83 case -ESHUTDOWN:
6f0f2669 84 goto free;
fb9987d0
S		 85 default:
86 break;
87 }
88
89 if (cmd) {
90 ath9k_htc_txcompletion_cb(cmd->hif_dev->htc_handle,
2f80194c 91 cmd->skb, true);
fb9987d0 92 kfree(cmd);
fb9987d0 93 }
6f0f2669
S		 94
95 return;
96free:
0fa35a58 97 kfree_skb(cmd->skb);
6f0f2669 98 kfree(cmd);
fb9987d0
S		 99}
100
101static int hif_usb_send_regout(struct hif_device_usb *hif_dev,
102 struct sk_buff *skb)
103{
104 struct urb *urb;
105 struct cmd_buf *cmd;
106 int ret = 0;
107
108 urb = usb_alloc_urb(0, GFP_KERNEL);
109 if (urb == NULL)
110 return -ENOMEM;
111
112 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
113 if (cmd == NULL) {
114 usb_free_urb(urb);
115 return -ENOMEM;
116 }
117
118 cmd->skb = skb;
119 cmd->hif_dev = hif_dev;
120
2b721118
OR		 121 usb_fill_int_urb(urb, hif_dev->udev,
122 usb_sndintpipe(hif_dev->udev, USB_REG_OUT_PIPE),
fb9987d0 123 skb->data, skb->len,
2b721118 124 hif_usb_regout_cb, cmd, 1);
fb9987d0 125
6f0f2669 126 usb_anchor_urb(urb, &hif_dev->regout_submitted);
fb9987d0
S		 127 ret = usb_submit_urb(urb, GFP_KERNEL);
128 if (ret) {
6f0f2669 129 usb_unanchor_urb(urb);
fb9987d0
S		 130 kfree(cmd);
131 }
6f0f2669 132 usb_free_urb(urb);
fb9987d0
S		 133
134 return ret;
135}
136
2f80194c
SM		 137static void hif_usb_mgmt_cb(struct urb *urb)
138{
139 struct cmd_buf *cmd = (struct cmd_buf *)urb->context;
02c5172c 140 struct hif_device_usb *hif_dev;
2f80194c
SM		 141 bool txok = true;
142
143 if (!cmd || !cmd->skb || !cmd->hif_dev)
144 return;
145
02c5172c
RM		 146 hif_dev = cmd->hif_dev;
147
2f80194c
SM		 148 switch (urb->status) {
149 case 0:
150 break;
151 case -ENOENT:
152 case -ECONNRESET:
153 case -ENODEV:
154 case -ESHUTDOWN:
155 txok = false;
156
157 /*
158 * If the URBs are being flushed, no need to complete
159 * this packet.
160 */
161 spin_lock(&hif_dev->tx.tx_lock);
162 if (hif_dev->tx.flags & HIF_USB_TX_FLUSH) {
163 spin_unlock(&hif_dev->tx.tx_lock);
164 dev_kfree_skb_any(cmd->skb);
165 kfree(cmd);
166 return;
167 }
168 spin_unlock(&hif_dev->tx.tx_lock);
169
170 break;
171 default:
172 txok = false;
173 break;
174 }
175
176 skb_pull(cmd->skb, 4);
177 ath9k_htc_txcompletion_cb(cmd->hif_dev->htc_handle,
178 cmd->skb, txok);
179 kfree(cmd);
180}
181
182static int hif_usb_send_mgmt(struct hif_device_usb *hif_dev,
183 struct sk_buff *skb)
184{
185 struct urb *urb;
186 struct cmd_buf *cmd;
187 int ret = 0;
188 __le16 *hdr;
189
190 urb = usb_alloc_urb(0, GFP_ATOMIC);
191 if (urb == NULL)
192 return -ENOMEM;
193
194 cmd = kzalloc(sizeof(*cmd), GFP_ATOMIC);
195 if (cmd == NULL) {
196 usb_free_urb(urb);
197 return -ENOMEM;
198 }
199
200 cmd->skb = skb;
201 cmd->hif_dev = hif_dev;
202
203 hdr = (__le16 *) skb_push(skb, 4);
204 *hdr++ = cpu_to_le16(skb->len - 4);
205 *hdr++ = cpu_to_le16(ATH_USB_TX_STREAM_MODE_TAG);
206
207 usb_fill_bulk_urb(urb, hif_dev->udev,
208 usb_sndbulkpipe(hif_dev->udev, USB_WLAN_TX_PIPE),
209 skb->data, skb->len,
210 hif_usb_mgmt_cb, cmd);
211
212 usb_anchor_urb(urb, &hif_dev->mgmt_submitted);
213 ret = usb_submit_urb(urb, GFP_ATOMIC);
214 if (ret) {
215 usb_unanchor_urb(urb);
216 kfree(cmd);
217 }
218 usb_free_urb(urb);
219
220 return ret;
221}
222
c11d8f89
S		 223static inline void ath9k_skb_queue_purge(struct hif_device_usb *hif_dev,
224 struct sk_buff_head *list)
225{
226 struct sk_buff *skb;
227
228 while ((skb = __skb_dequeue(list)) != NULL) {
229 dev_kfree_skb_any(skb);
b587fc81
SM		 230 }
231}
232
233static inline void ath9k_skb_queue_complete(struct hif_device_usb *hif_dev,
234 struct sk_buff_head *queue,
235 bool txok)
236{
237 struct sk_buff *skb;
238
239 while ((skb = __skb_dequeue(queue)) != NULL) {
68185a4b
BG		 240#ifdef CONFIG_ATH9K_HTC_DEBUGFS
241 int ln = skb->len;
242#endif
b587fc81
SM		 243 ath9k_htc_txcompletion_cb(hif_dev->htc_handle,
244 skb, txok);
68185a4b 245 if (txok) {
dfa8fc69 246 TX_STAT_INC(skb_success);
68185a4b
BG		 247 TX_STAT_ADD(skb_success_bytes, ln);
248 }
dfa8fc69
JL		 249 else
250 TX_STAT_INC(skb_failed);
c11d8f89
S		 251 }
252}
253
fb9987d0
S		 254static void hif_usb_tx_cb(struct urb *urb)
255{
256 struct tx_buf *tx_buf = (struct tx_buf *) urb->context;
690e781c 257 struct hif_device_usb *hif_dev;
b587fc81 258 bool txok = true;
fb9987d0 259
690e781c 260 if (!tx_buf || !tx_buf->hif_dev)
fb9987d0
S		 261 return;
262
690e781c
DC		 263 hif_dev = tx_buf->hif_dev;
264
fb9987d0
S		 265 switch (urb->status) {
266 case 0:
267 break;
268 case -ENOENT:
269 case -ECONNRESET:
fb9987d0
S		 270 case -ENODEV:
271 case -ESHUTDOWN:
b587fc81 272 txok = false;
ff8f59b5
SM		 273
274 /*
275 * If the URBs are being flushed, no need to add this
276 * URB to the free list.
277 */
278 spin_lock(&hif_dev->tx.tx_lock);
279 if (hif_dev->tx.flags & HIF_USB_TX_FLUSH) {
280 spin_unlock(&hif_dev->tx.tx_lock);
b587fc81 281 ath9k_skb_queue_purge(hif_dev, &tx_buf->skb_queue);
ff8f59b5
SM		 282 return;
283 }
284 spin_unlock(&hif_dev->tx.tx_lock);
285
b587fc81 286 break;
fb9987d0 287 default:
b587fc81 288 txok = false;
fb9987d0
S		 289 break;
290 }
291
b587fc81 292 ath9k_skb_queue_complete(hif_dev, &tx_buf->skb_queue, txok);
c11d8f89 293
c11d8f89
S		 294 /* Re-initialize the SKB queue */
295 tx_buf->len = tx_buf->offset = 0;
296 __skb_queue_head_init(&tx_buf->skb_queue);
297
298 /* Add this TX buffer to the free list */
299 spin_lock(&hif_dev->tx.tx_lock);
300 list_move_tail(&tx_buf->list, &hif_dev->tx.tx_buf);
301 hif_dev->tx.tx_buf_cnt++;
302 if (!(hif_dev->tx.flags & HIF_USB_TX_STOP))
303 __hif_usb_tx(hif_dev); /* Check for pending SKBs */
304 TX_STAT_INC(buf_completed);
305 spin_unlock(&hif_dev->tx.tx_lock);
f8e1d080
ML		 306}
307
fb9987d0
S		 308/* TX lock has to be taken */
309static int __hif_usb_tx(struct hif_device_usb *hif_dev)
310{
311 struct tx_buf *tx_buf = NULL;
312 struct sk_buff *nskb = NULL;
313 int ret = 0, i;
2c27392d 314 u16 tx_skb_cnt = 0;
fb9987d0 315 u8 *buf;
2c27392d 316 __le16 *hdr;
fb9987d0
S		 317
318 if (hif_dev->tx.tx_skb_cnt == 0)
319 return 0;
320
321 /* Check if a free TX buffer is available */
322 if (list_empty(&hif_dev->tx.tx_buf))
323 return 0;
324
325 tx_buf = list_first_entry(&hif_dev->tx.tx_buf, struct tx_buf, list);
c11d8f89 326 list_move_tail(&tx_buf->list, &hif_dev->tx.tx_pending);
fb9987d0
S		 327 hif_dev->tx.tx_buf_cnt--;
328
329 tx_skb_cnt = min_t(u16, hif_dev->tx.tx_skb_cnt, MAX_TX_AGGR_NUM);
330
331 for (i = 0; i < tx_skb_cnt; i++) {
332 nskb = __skb_dequeue(&hif_dev->tx.tx_skb_queue);
333
334 /* Should never be NULL */
335 BUG_ON(!nskb);
336
337 hif_dev->tx.tx_skb_cnt--;
338
339 buf = tx_buf->buf;
340 buf += tx_buf->offset;
2c27392d
SM		 341 hdr = (__le16 *)buf;
342 *hdr++ = cpu_to_le16(nskb->len);
343 *hdr++ = cpu_to_le16(ATH_USB_TX_STREAM_MODE_TAG);
fb9987d0
S		 344 buf += 4;
345 memcpy(buf, nskb->data, nskb->len);
346 tx_buf->len = nskb->len + 4;
347
348 if (i < (tx_skb_cnt - 1))
349 tx_buf->offset += (((tx_buf->len - 1) / 4) + 1) * 4;
350
351 if (i == (tx_skb_cnt - 1))
352 tx_buf->len += tx_buf->offset;
353
354 __skb_queue_tail(&tx_buf->skb_queue, nskb);
355 TX_STAT_INC(skb_queued);
356 }
357
358 usb_fill_bulk_urb(tx_buf->urb, hif_dev->udev,
359 usb_sndbulkpipe(hif_dev->udev, USB_WLAN_TX_PIPE),
360 tx_buf->buf, tx_buf->len,
361 hif_usb_tx_cb, tx_buf);
362
363 ret = usb_submit_urb(tx_buf->urb, GFP_ATOMIC);
364 if (ret) {
365 tx_buf->len = tx_buf->offset = 0;
b587fc81 366 ath9k_skb_queue_complete(hif_dev, &tx_buf->skb_queue, false);
fb9987d0
S		 367 __skb_queue_head_init(&tx_buf->skb_queue);
368 list_move_tail(&tx_buf->list, &hif_dev->tx.tx_buf);
369 hif_dev->tx.tx_buf_cnt++;
370 }
371
372 if (!ret)
373 TX_STAT_INC(buf_queued);
374
375 return ret;
376}
377
40dc9e4b 378static int hif_usb_send_tx(struct hif_device_usb *hif_dev, struct sk_buff *skb)
fb9987d0 379{
40dc9e4b 380 struct ath9k_htc_tx_ctl *tx_ctl;
fb9987d0 381 unsigned long flags;
2f80194c 382 int ret = 0;
fb9987d0
S		 383
384 spin_lock_irqsave(&hif_dev->tx.tx_lock, flags);
385
386 if (hif_dev->tx.flags & HIF_USB_TX_STOP) {
387 spin_unlock_irqrestore(&hif_dev->tx.tx_lock, flags);
388 return -ENODEV;
389 }
390
391 /* Check if the max queue count has been reached */
392 if (hif_dev->tx.tx_skb_cnt > MAX_TX_BUF_NUM) {
393 spin_unlock_irqrestore(&hif_dev->tx.tx_lock, flags);
394 return -ENOMEM;
395 }
396
2f80194c 397 spin_unlock_irqrestore(&hif_dev->tx.tx_lock, flags);
fb9987d0 398
40dc9e4b
SM		 399 tx_ctl = HTC_SKB_CB(skb);
400
2f80194c
SM		 401 /* Mgmt/Beacon frames don't use the TX buffer pool */
402 if ((tx_ctl->type == ATH9K_HTC_MGMT) ||
403 (tx_ctl->type == ATH9K_HTC_BEACON)) {
404 ret = hif_usb_send_mgmt(hif_dev, skb);
405 }
406
407 spin_lock_irqsave(&hif_dev->tx.tx_lock, flags);
408
409 if ((tx_ctl->type == ATH9K_HTC_NORMAL) ||
410 (tx_ctl->type == ATH9K_HTC_AMPDU)) {
411 __skb_queue_tail(&hif_dev->tx.tx_skb_queue, skb);
412 hif_dev->tx.tx_skb_cnt++;
413 }
fb9987d0
S		 414
415 /* Check if AMPDUs have to be sent immediately */
2f80194c 416 if ((hif_dev->tx.tx_buf_cnt == MAX_TX_URB_NUM) &&
fb9987d0
S		 417 (hif_dev->tx.tx_skb_cnt < 2)) {
418 __hif_usb_tx(hif_dev);
419 }
420
421 spin_unlock_irqrestore(&hif_dev->tx.tx_lock, flags);
422
2f80194c 423 return ret;
fb9987d0
S		 424}
425
e1fe7c38 426static void hif_usb_start(void *hif_handle)
fb9987d0
S		 427{
428 struct hif_device_usb *hif_dev = (struct hif_device_usb *)hif_handle;
429 unsigned long flags;
430
431 hif_dev->flags |= HIF_USB_START;
432
433 spin_lock_irqsave(&hif_dev->tx.tx_lock, flags);
434 hif_dev->tx.flags &= ~HIF_USB_TX_STOP;
435 spin_unlock_irqrestore(&hif_dev->tx.tx_lock, flags);
436}
437
e1fe7c38 438static void hif_usb_stop(void *hif_handle)
fb9987d0
S		 439{
440 struct hif_device_usb *hif_dev = (struct hif_device_usb *)hif_handle;
ff8f59b5 441 struct tx_buf *tx_buf = NULL, *tx_buf_tmp = NULL;
fb9987d0
S		 442 unsigned long flags;
443
444 spin_lock_irqsave(&hif_dev->tx.tx_lock, flags);
b587fc81 445 ath9k_skb_queue_complete(hif_dev, &hif_dev->tx.tx_skb_queue, false);
fb9987d0
S		 446 hif_dev->tx.tx_skb_cnt = 0;
447 hif_dev->tx.flags |= HIF_USB_TX_STOP;
448 spin_unlock_irqrestore(&hif_dev->tx.tx_lock, flags);
ff8f59b5
SM		 449
450 /* The pending URBs have to be canceled. */
451 list_for_each_entry_safe(tx_buf, tx_buf_tmp,
452 &hif_dev->tx.tx_pending, list) {
453 usb_kill_urb(tx_buf->urb);
454 }
2f80194c
SM		 455
456 usb_kill_anchored_urbs(&hif_dev->mgmt_submitted);
fb9987d0
S		 457}
458
40dc9e4b 459static int hif_usb_send(void *hif_handle, u8 pipe_id, struct sk_buff *skb)
fb9987d0
S		 460{
461 struct hif_device_usb *hif_dev = (struct hif_device_usb *)hif_handle;
462 int ret = 0;
463
464 switch (pipe_id) {
465 case USB_WLAN_TX_PIPE:
40dc9e4b 466 ret = hif_usb_send_tx(hif_dev, skb);
fb9987d0
S		 467 break;
468 case USB_REG_OUT_PIPE:
469 ret = hif_usb_send_regout(hif_dev, skb);
470 break;
471 default:
6335ed0f
S		 472 dev_err(&hif_dev->udev->dev,
473 "ath9k_htc: Invalid TX pipe: %d\n", pipe_id);
fb9987d0
S		 474 ret = -EINVAL;
475 break;
476 }
477
478 return ret;
479}
480
84c9e164
SM		 481static inline bool check_index(struct sk_buff *skb, u8 idx)
482{
483 struct ath9k_htc_tx_ctl *tx_ctl;
484
485 tx_ctl = HTC_SKB_CB(skb);
486
487 if ((tx_ctl->type == ATH9K_HTC_AMPDU) &&
488 (tx_ctl->sta_idx == idx))
489 return true;
490
491 return false;
492}
493
494static void hif_usb_sta_drain(void *hif_handle, u8 idx)
495{
496 struct hif_device_usb *hif_dev = (struct hif_device_usb *)hif_handle;
497 struct sk_buff *skb, *tmp;
498 unsigned long flags;
499
500 spin_lock_irqsave(&hif_dev->tx.tx_lock, flags);
501
502 skb_queue_walk_safe(&hif_dev->tx.tx_skb_queue, skb, tmp) {
503 if (check_index(skb, idx)) {
504 __skb_unlink(skb, &hif_dev->tx.tx_skb_queue);
505 ath9k_htc_txcompletion_cb(hif_dev->htc_handle,
506 skb, false);
507 hif_dev->tx.tx_skb_cnt--;
508 TX_STAT_INC(skb_failed);
509 }
510 }
511
512 spin_unlock_irqrestore(&hif_dev->tx.tx_lock, flags);
513}
514
fb9987d0
S		 515static struct ath9k_htc_hif hif_usb = {
516 .transport = ATH9K_HIF_USB,
517 .name = "ath9k_hif_usb",
518
519 .control_ul_pipe = USB_REG_OUT_PIPE,
520 .control_dl_pipe = USB_REG_IN_PIPE,
521
522 .start = hif_usb_start,
523 .stop = hif_usb_stop,
84c9e164 524 .sta_drain = hif_usb_sta_drain,
fb9987d0
S		 525 .send = hif_usb_send,
526};
527
528static void ath9k_hif_usb_rx_stream(struct hif_device_usb *hif_dev,
529 struct sk_buff *skb)
530{
c503269a 531 struct sk_buff *nskb, *skb_pool[MAX_PKT_NUM_IN_TRANSFER];
44b23b48
JP		 532 int index = 0, i = 0, len = skb->len;
533 int rx_remain_len, rx_pkt_len;
534 u16 pool_index = 0;
fb9987d0
S		 535 u8 *ptr;
536
46baa1a2
S		 537 spin_lock(&hif_dev->rx_lock);
538
fb9987d0
S		 539 rx_remain_len = hif_dev->rx_remain_len;
540 rx_pkt_len = hif_dev->rx_transfer_len;
541
542 if (rx_remain_len != 0) {
543 struct sk_buff *remain_skb = hif_dev->remain_skb;
544
545 if (remain_skb) {
546 ptr = (u8 *) remain_skb->data;
547
548 index = rx_remain_len;
549 rx_remain_len -= hif_dev->rx_pad_len;
550 ptr += rx_pkt_len;
551
552 memcpy(ptr, skb->data, rx_remain_len);
553
554 rx_pkt_len += rx_remain_len;
555 hif_dev->rx_remain_len = 0;
556 skb_put(remain_skb, rx_pkt_len);
557
558 skb_pool[pool_index++] = remain_skb;
559
560 } else {
561 index = rx_remain_len;
562 }
563 }
564
46baa1a2
S		 565 spin_unlock(&hif_dev->rx_lock);
566
fb9987d0 567 while (index < len) {
44b23b48
JP		 568 u16 pkt_len;
569 u16 pkt_tag;
570 u16 pad_len;
571 int chk_idx;
572
fb9987d0
S		 573 ptr = (u8 *) skb->data;
574
78fa99ab
PR		 575 pkt_len = get_unaligned_le16(ptr + index);
576 pkt_tag = get_unaligned_le16(ptr + index + 2);
fb9987d0 577
44b23b48
JP		 578 if (pkt_tag != ATH_USB_RX_STREAM_MODE_TAG) {
579 RX_STAT_INC(skb_dropped);
580 return;
581 }
582
583 pad_len = 4 - (pkt_len & 0x3);
584 if (pad_len == 4)
585 pad_len = 0;
586
587 chk_idx = index;
588 index = index + 4 + pkt_len + pad_len;
589
590 if (index > MAX_RX_BUF_SIZE) {
591 spin_lock(&hif_dev->rx_lock);
592 hif_dev->rx_remain_len = index - MAX_RX_BUF_SIZE;
593 hif_dev->rx_transfer_len =
594 MAX_RX_BUF_SIZE - chk_idx - 4;
595 hif_dev->rx_pad_len = pad_len;
596
597 nskb = __dev_alloc_skb(pkt_len + 32, GFP_ATOMIC);
598 if (!nskb) {
599 dev_err(&hif_dev->udev->dev,
600 "ath9k_htc: RX memory allocation error\n");
46baa1a2 601 spin_unlock(&hif_dev->rx_lock);
44b23b48 602 goto err;
fb9987d0 603 }
44b23b48
JP		 604 skb_reserve(nskb, 32);
605 RX_STAT_INC(skb_allocated);
606
607 memcpy(nskb->data, &(skb->data[chk_idx+4]),
608 hif_dev->rx_transfer_len);
609
610 /* Record the buffer pointer */
611 hif_dev->remain_skb = nskb;
612 spin_unlock(&hif_dev->rx_lock);
fb9987d0 613 } else {
44b23b48
JP		 614 nskb = __dev_alloc_skb(pkt_len + 32, GFP_ATOMIC);
615 if (!nskb) {
616 dev_err(&hif_dev->udev->dev,
617 "ath9k_htc: RX memory allocation error\n");
618 goto err;
619 }
620 skb_reserve(nskb, 32);
621 RX_STAT_INC(skb_allocated);
622
623 memcpy(nskb->data, &(skb->data[chk_idx+4]), pkt_len);
624 skb_put(nskb, pkt_len);
625 skb_pool[pool_index++] = nskb;
fb9987d0
S		 626 }
627 }
628
629err:
fb9987d0 630 for (i = 0; i < pool_index; i++) {
68185a4b 631 RX_STAT_ADD(skb_completed_bytes, skb_pool[i]->len);
fb9987d0
S		 632 ath9k_htc_rx_msg(hif_dev->htc_handle, skb_pool[i],
633 skb_pool[i]->len, USB_WLAN_RX_PIPE);
634 RX_STAT_INC(skb_completed);
635 }
636}
637
638static void ath9k_hif_usb_rx_cb(struct urb *urb)
639{
640 struct sk_buff *skb = (struct sk_buff *) urb->context;
b2767363 641 struct hif_device_usb *hif_dev =
fb9987d0
S		 642 usb_get_intfdata(usb_ifnum_to_if(urb->dev, 0));
643 int ret;
644
6335ed0f
S		 645 if (!skb)
646 return;
647
fb9987d0
S		 648 if (!hif_dev)
649 goto free;
650
651 switch (urb->status) {
652 case 0:
653 break;
654 case -ENOENT:
655 case -ECONNRESET:
656 case -ENODEV:
657 case -ESHUTDOWN:
658 goto free;
659 default:
660 goto resubmit;
661 }
662
663 if (likely(urb->actual_length != 0)) {
664 skb_put(skb, urb->actual_length);
fb9987d0 665 ath9k_hif_usb_rx_stream(hif_dev, skb);
fb9987d0
S		 666 }
667
668resubmit:
669 skb_reset_tail_pointer(skb);
670 skb_trim(skb, 0);
671
6335ed0f 672 usb_anchor_urb(urb, &hif_dev->rx_submitted);
fb9987d0 673 ret = usb_submit_urb(urb, GFP_ATOMIC);
6335ed0f
S		 674 if (ret) {
675 usb_unanchor_urb(urb);
fb9987d0 676 goto free;
6335ed0f 677 }
fb9987d0
S		 678
679 return;
680free:
f28a7b30 681 kfree_skb(skb);
fb9987d0
S		 682}
683
684static void ath9k_hif_usb_reg_in_cb(struct urb *urb)
685{
686 struct sk_buff *skb = (struct sk_buff *) urb->context;
687 struct sk_buff *nskb;
b2767363 688 struct hif_device_usb *hif_dev =
fb9987d0
S		 689 usb_get_intfdata(usb_ifnum_to_if(urb->dev, 0));
690 int ret;
691
6335ed0f
S		 692 if (!skb)
693 return;
694
fb9987d0
S		 695 if (!hif_dev)
696 goto free;
697
698 switch (urb->status) {
699 case 0:
700 break;
701 case -ENOENT:
702 case -ECONNRESET:
703 case -ENODEV:
704 case -ESHUTDOWN:
705 goto free;
706 default:
3deff760
SM		 707 skb_reset_tail_pointer(skb);
708 skb_trim(skb, 0);
709
fb9987d0
S		 710 goto resubmit;
711 }
712
713 if (likely(urb->actual_length != 0)) {
714 skb_put(skb, urb->actual_length);
715
5ab0af32
S		 716 /* Process the command first */
717 ath9k_htc_rx_msg(hif_dev->htc_handle, skb,
718 skb->len, USB_REG_IN_PIPE);
719
720
e6c6d33c 721 nskb = alloc_skb(MAX_REG_IN_BUF_SIZE, GFP_ATOMIC);
5ab0af32
S		 722 if (!nskb) {
723 dev_err(&hif_dev->udev->dev,
724 "ath9k_htc: REG_IN memory allocation failure\n");
725 urb->context = NULL;
726 return;
727 }
fb9987d0 728
2b721118
OR		 729 usb_fill_int_urb(urb, hif_dev->udev,
730 usb_rcvintpipe(hif_dev->udev,
0f529e98 731 USB_REG_IN_PIPE),
fb9987d0 732 nskb->data, MAX_REG_IN_BUF_SIZE,
2b721118 733 ath9k_hif_usb_reg_in_cb, nskb, 1);
fb9987d0
S		 734 }
735
736resubmit:
3deff760 737 usb_anchor_urb(urb, &hif_dev->reg_in_submitted);
fb9987d0 738 ret = usb_submit_urb(urb, GFP_ATOMIC);
3deff760
SM		 739 if (ret) {
740 usb_unanchor_urb(urb);
fb9987d0 741 goto free;
3deff760 742 }
fb9987d0
S		 743
744 return;
745free:
e6c6d33c 746 kfree_skb(skb);
6335ed0f 747 urb->context = NULL;
fb9987d0
S		 748}
749
750static void ath9k_hif_usb_dealloc_tx_urbs(struct hif_device_usb *hif_dev)
751{
fb9987d0 752 struct tx_buf *tx_buf = NULL, *tx_buf_tmp = NULL;
ff8f59b5 753 unsigned long flags;
fb9987d0 754
c11d8f89
S		 755 list_for_each_entry_safe(tx_buf, tx_buf_tmp,
756 &hif_dev->tx.tx_buf, list) {
757 usb_kill_urb(tx_buf->urb);
fb9987d0
S		 758 list_del(&tx_buf->list);
759 usb_free_urb(tx_buf->urb);
760 kfree(tx_buf->buf);
761 kfree(tx_buf);
762 }
763
ff8f59b5
SM		 764 spin_lock_irqsave(&hif_dev->tx.tx_lock, flags);
765 hif_dev->tx.flags |= HIF_USB_TX_FLUSH;
766 spin_unlock_irqrestore(&hif_dev->tx.tx_lock, flags);
767
fb9987d0
S		 768 list_for_each_entry_safe(tx_buf, tx_buf_tmp,
769 &hif_dev->tx.tx_pending, list) {
770 usb_kill_urb(tx_buf->urb);
771 list_del(&tx_buf->list);
772 usb_free_urb(tx_buf->urb);
773 kfree(tx_buf->buf);
774 kfree(tx_buf);
775 }
2f80194c
SM		 776
777 usb_kill_anchored_urbs(&hif_dev->mgmt_submitted);
fb9987d0
S		 778}
779
780static int ath9k_hif_usb_alloc_tx_urbs(struct hif_device_usb *hif_dev)
781{
782 struct tx_buf *tx_buf;
783 int i;
784
785 INIT_LIST_HEAD(&hif_dev->tx.tx_buf);
786 INIT_LIST_HEAD(&hif_dev->tx.tx_pending);
787 spin_lock_init(&hif_dev->tx.tx_lock);
788 __skb_queue_head_init(&hif_dev->tx.tx_skb_queue);
2f80194c 789 init_usb_anchor(&hif_dev->mgmt_submitted);
fb9987d0
S		 790
791 for (i = 0; i < MAX_TX_URB_NUM; i++) {
792 tx_buf = kzalloc(sizeof(struct tx_buf), GFP_KERNEL);
793 if (!tx_buf)
794 goto err;
795
796 tx_buf->buf = kzalloc(MAX_TX_BUF_SIZE, GFP_KERNEL);
797 if (!tx_buf->buf)
798 goto err;
799
800 tx_buf->urb = usb_alloc_urb(0, GFP_KERNEL);
801 if (!tx_buf->urb)
802 goto err;
803
804 tx_buf->hif_dev = hif_dev;
805 __skb_queue_head_init(&tx_buf->skb_queue);
806
807 list_add_tail(&tx_buf->list, &hif_dev->tx.tx_buf);
808 }
809
810 hif_dev->tx.tx_buf_cnt = MAX_TX_URB_NUM;
811
812 return 0;
813err:
7606688a
DC		 814 if (tx_buf) {
815 kfree(tx_buf->buf);
816 kfree(tx_buf);
817 }
fb9987d0
S		 818 ath9k_hif_usb_dealloc_tx_urbs(hif_dev);
819 return -ENOMEM;
820}
821
fb9987d0
S		 822static void ath9k_hif_usb_dealloc_rx_urbs(struct hif_device_usb *hif_dev)
823{
6335ed0f 824 usb_kill_anchored_urbs(&hif_dev->rx_submitted);
fb9987d0
S		 825}
826
827static int ath9k_hif_usb_alloc_rx_urbs(struct hif_device_usb *hif_dev)
828{
6335ed0f
S		 829 struct urb *urb = NULL;
830 struct sk_buff *skb = NULL;
fb9987d0
S		 831 int i, ret;
832
6335ed0f 833 init_usb_anchor(&hif_dev->rx_submitted);
46baa1a2 834 spin_lock_init(&hif_dev->rx_lock);
6335ed0f 835
fb9987d0
S		 836 for (i = 0; i < MAX_RX_URB_NUM; i++) {
837
838 /* Allocate URB */
6335ed0f
S		 839 urb = usb_alloc_urb(0, GFP_KERNEL);
840 if (urb == NULL) {
fb9987d0 841 ret = -ENOMEM;
6335ed0f 842 goto err_urb;
fb9987d0
S		 843 }
844
845 /* Allocate buffer */
f28a7b30 846 skb = alloc_skb(MAX_RX_BUF_SIZE, GFP_KERNEL);
6335ed0f
S		 847 if (!skb) {
848 ret = -ENOMEM;
849 goto err_skb;
850 }
fb9987d0 851
6335ed0f
S		 852 usb_fill_bulk_urb(urb, hif_dev->udev,
853 usb_rcvbulkpipe(hif_dev->udev,
854 USB_WLAN_RX_PIPE),
855 skb->data, MAX_RX_BUF_SIZE,
856 ath9k_hif_usb_rx_cb, skb);
857
858 /* Anchor URB */
859 usb_anchor_urb(urb, &hif_dev->rx_submitted);
fb9987d0 860
6335ed0f
S		 861 /* Submit URB */
862 ret = usb_submit_urb(urb, GFP_KERNEL);
863 if (ret) {
864 usb_unanchor_urb(urb);
865 goto err_submit;
866 }
66b10e33
S		 867
868 /*
869 * Drop reference count.
870 * This ensures that the URB is freed when killing them.
871 */
872 usb_free_urb(urb);
fb9987d0
S		 873 }
874
875 return 0;
876
6335ed0f 877err_submit:
f28a7b30 878 kfree_skb(skb);
6335ed0f
S		 879err_skb:
880 usb_free_urb(urb);
881err_urb:
fb9987d0
S		 882 ath9k_hif_usb_dealloc_rx_urbs(hif_dev);
883 return ret;
884}
885
3deff760 886static void ath9k_hif_usb_dealloc_reg_in_urbs(struct hif_device_usb *hif_dev)
fb9987d0 887{
3deff760 888 usb_kill_anchored_urbs(&hif_dev->reg_in_submitted);
fb9987d0
S		 889}
890
3deff760 891static int ath9k_hif_usb_alloc_reg_in_urbs(struct hif_device_usb *hif_dev)
fb9987d0 892{
3deff760
SM		 893 struct urb *urb = NULL;
894 struct sk_buff *skb = NULL;
895 int i, ret;
fb9987d0 896
3deff760 897 init_usb_anchor(&hif_dev->reg_in_submitted);
fb9987d0 898
3deff760 899 for (i = 0; i < MAX_REG_IN_URB_NUM; i++) {
fb9987d0 900
3deff760
SM		 901 /* Allocate URB */
902 urb = usb_alloc_urb(0, GFP_KERNEL);
903 if (urb == NULL) {
904 ret = -ENOMEM;
905 goto err_urb;
906 }
fb9987d0 907
3deff760
SM		 908 /* Allocate buffer */
909 skb = alloc_skb(MAX_REG_IN_BUF_SIZE, GFP_KERNEL);
910 if (!skb) {
911 ret = -ENOMEM;
912 goto err_skb;
913 }
914
2b721118
OR		 915 usb_fill_int_urb(urb, hif_dev->udev,
916 usb_rcvintpipe(hif_dev->udev,
3deff760
SM		 917 USB_REG_IN_PIPE),
918 skb->data, MAX_REG_IN_BUF_SIZE,
2b721118 919 ath9k_hif_usb_reg_in_cb, skb, 1);
3deff760
SM		 920
921 /* Anchor URB */
922 usb_anchor_urb(urb, &hif_dev->reg_in_submitted);
923
924 /* Submit URB */
925 ret = usb_submit_urb(urb, GFP_KERNEL);
926 if (ret) {
927 usb_unanchor_urb(urb);
928 goto err_submit;
929 }
930
931 /*
932 * Drop reference count.
933 * This ensures that the URB is freed when killing them.
934 */
935 usb_free_urb(urb);
936 }
fb9987d0
S		 937
938 return 0;
939
3deff760
SM		 940err_submit:
941 kfree_skb(skb);
942err_skb:
943 usb_free_urb(urb);
944err_urb:
945 ath9k_hif_usb_dealloc_reg_in_urbs(hif_dev);
946 return ret;
fb9987d0
S		 947}
948
949static int ath9k_hif_usb_alloc_urbs(struct hif_device_usb *hif_dev)
950{
6f0f2669
S		 951 /* Register Write */
952 init_usb_anchor(&hif_dev->regout_submitted);
953
fb9987d0
S		 954 /* TX */
955 if (ath9k_hif_usb_alloc_tx_urbs(hif_dev) < 0)
956 goto err;
957
958 /* RX */
959 if (ath9k_hif_usb_alloc_rx_urbs(hif_dev) < 0)
f8036965 960 goto err_rx;
fb9987d0 961
6f0f2669 962 /* Register Read */
3deff760 963 if (ath9k_hif_usb_alloc_reg_in_urbs(hif_dev) < 0)
f8036965 964 goto err_reg;
fb9987d0
S		 965
966 return 0;
f8036965
RM		 967err_reg:
968 ath9k_hif_usb_dealloc_rx_urbs(hif_dev);
969err_rx:
970 ath9k_hif_usb_dealloc_tx_urbs(hif_dev);
fb9987d0
S		 971err:
972 return -ENOMEM;
973}
974
1d8af8ca
SM		 975static void ath9k_hif_usb_dealloc_urbs(struct hif_device_usb *hif_dev)
976{
977 usb_kill_anchored_urbs(&hif_dev->regout_submitted);
3deff760 978 ath9k_hif_usb_dealloc_reg_in_urbs(hif_dev);
1d8af8ca
SM		 979 ath9k_hif_usb_dealloc_tx_urbs(hif_dev);
980 ath9k_hif_usb_dealloc_rx_urbs(hif_dev);
981}
982
0ed7b93e 983static int ath9k_hif_usb_download_fw(struct hif_device_usb *hif_dev)
fb9987d0
S		 984{
985 int transfer, err;
32e31de5
ML		 986 const void *data = hif_dev->fw_data;
987 size_t len = hif_dev->fw_size;
fb9987d0
S		 988 u32 addr = AR9271_FIRMWARE;
989 u8 *buf = kzalloc(4096, GFP_KERNEL);
b1762862 990 u32 firm_offset;
fb9987d0
S		 991
992 if (!buf)
993 return -ENOMEM;
994
995 while (len) {
291689fc 996 transfer = min_t(size_t, len, 4096);
fb9987d0
S		 997 memcpy(buf, data, transfer);
998
999 err = usb_control_msg(hif_dev->udev,
1000 usb_sndctrlpipe(hif_dev->udev, 0),
1001 FIRMWARE_DOWNLOAD, 0x40 | USB_DIR_OUT,
1002 addr >> 8, 0, buf, transfer, HZ);
1003 if (err < 0) {
1004 kfree(buf);
1005 return err;
1006 }
1007
1008 len -= transfer;
1009 data += transfer;
1010 addr += transfer;
1011 }
1012 kfree(buf);
1013
0ed7b93e 1014 if (IS_AR7010_DEVICE(hif_dev->usb_device_id->driver_info))
b1762862 1015 firm_offset = AR7010_FIRMWARE_TEXT;
fa6e15e0 1016 else
b1762862
S		 1017 firm_offset = AR9271_FIRMWARE_TEXT;
1018
fb9987d0
S		 1019 /*
1020 * Issue FW download complete command to firmware.
1021 */
1022 err = usb_control_msg(hif_dev->udev, usb_sndctrlpipe(hif_dev->udev, 0),
1023 FIRMWARE_DOWNLOAD_COMP,
1024 0x40 | USB_DIR_OUT,
b1762862 1025 firm_offset >> 8, 0, NULL, 0, HZ);
fb9987d0
S		 1026 if (err)
1027 return -EIO;
1028
1029 dev_info(&hif_dev->udev->dev, "ath9k_htc: Transferred FW: %s, size: %ld\n",
32e31de5 1030 hif_dev->fw_name, (unsigned long) hif_dev->fw_size);
fb9987d0
S		 1031
1032 return 0;
1033}
1034
0ed7b93e 1035static int ath9k_hif_usb_dev_init(struct hif_device_usb *hif_dev)
fb9987d0 1036{
2b721118 1037 int ret;
fb9987d0 1038
0ed7b93e 1039 ret = ath9k_hif_usb_download_fw(hif_dev);
1d8af8ca
SM		 1040 if (ret) {
1041 dev_err(&hif_dev->udev->dev,
ce43cee5
S		 1042 "ath9k_htc: Firmware - %s download failed\n",
1043 hif_dev->fw_name);
0ed7b93e 1044 return ret;
1d8af8ca
SM		 1045 }
1046
490b3f4e
RM		 1047 /* Alloc URBs */
1048 ret = ath9k_hif_usb_alloc_urbs(hif_dev);
1049 if (ret) {
1050 dev_err(&hif_dev->udev->dev,
1051 "ath9k_htc: Unable to allocate URBs\n");
0ed7b93e 1052 return ret;
490b3f4e
RM		 1053 }
1054
fb9987d0 1055 return 0;
fb9987d0
S		 1056}
1057
fb9987d0
S		 1058static void ath9k_hif_usb_dev_deinit(struct hif_device_usb *hif_dev)
1059{
1060 ath9k_hif_usb_dealloc_urbs(hif_dev);
0ed7b93e
SM		 1061}
1062
1063/*
1064 * If initialization fails or the FW cannot be retrieved,
1065 * detach the device.
1066 */
1067static void ath9k_hif_usb_firmware_fail(struct hif_device_usb *hif_dev)
1068{
e962610f
ML		 1069 struct device *dev = &hif_dev->udev->dev;
1070 struct device *parent = dev->parent;
0ed7b93e 1071
9494849e 1072 complete_all(&hif_dev->fw_done);
0ed7b93e
SM		 1073
1074 if (parent)
1075 device_lock(parent);
1076
e962610f 1077 device_release_driver(dev);
0ed7b93e
SM		 1078
1079 if (parent)
1080 device_unlock(parent);
1081}
1082
1083static void ath9k_hif_usb_firmware_cb(const struct firmware *fw, void *context)
1084{
1085 struct hif_device_usb *hif_dev = context;
1086 int ret;
1087
1088 if (!fw) {
1089 dev_err(&hif_dev->udev->dev,
1090 "ath9k_htc: Failed to get firmware %s\n",
1091 hif_dev->fw_name);
1092 goto err_fw;
1093 }
1094
1095 hif_dev->htc_handle = ath9k_htc_hw_alloc(hif_dev, &hif_usb,
1096 &hif_dev->udev->dev);
32e31de5
ML		 1097 if (hif_dev->htc_handle == NULL)
1098 goto err_dev_alloc;
0ed7b93e 1099
32e31de5
ML		 1100 hif_dev->fw_data = fw->data;
1101 hif_dev->fw_size = fw->size;
0ed7b93e
SM		 1102
1103 /* Proceed with initialization */
1104
1105 ret = ath9k_hif_usb_dev_init(hif_dev);
1106 if (ret)
1107 goto err_dev_init;
1108
1109 ret = ath9k_htc_hw_init(hif_dev->htc_handle,
1110 &hif_dev->interface->dev,
1111 hif_dev->usb_device_id->idProduct,
1112 hif_dev->udev->product,
1113 hif_dev->usb_device_id->driver_info);
1114 if (ret) {
1115 ret = -EINVAL;
1116 goto err_htc_hw_init;
1117 }
1118
32e31de5
ML		 1119 release_firmware(fw);
1120 hif_dev->flags |= HIF_USB_READY;
9494849e 1121 complete_all(&hif_dev->fw_done);
0ed7b93e
SM		 1122
1123 return;
1124
1125err_htc_hw_init:
1126 ath9k_hif_usb_dev_deinit(hif_dev);
1127err_dev_init:
1128 ath9k_htc_hw_free(hif_dev->htc_handle);
32e31de5 1129err_dev_alloc:
0ed7b93e 1130 release_firmware(fw);
0ed7b93e
SM		 1131err_fw:
1132 ath9k_hif_usb_firmware_fail(hif_dev);
fb9987d0
S		 1133}
1134
36bcce43
SM		 1135/*
1136 * An exact copy of the function from zd1211rw.
1137 */
1138static int send_eject_command(struct usb_interface *interface)
1139{
1140 struct usb_device *udev = interface_to_usbdev(interface);
1141 struct usb_host_interface *iface_desc = &interface->altsetting[0];
1142 struct usb_endpoint_descriptor *endpoint;
1143 unsigned char *cmd;
1144 u8 bulk_out_ep;
1145 int r;
1146
1147 /* Find bulk out endpoint */
1148 for (r = 1; r >= 0; r--) {
1149 endpoint = &iface_desc->endpoint[r].desc;
1150 if (usb_endpoint_dir_out(endpoint) &&
1151 usb_endpoint_xfer_bulk(endpoint)) {
1152 bulk_out_ep = endpoint->bEndpointAddress;
1153 break;
1154 }
1155 }
1156 if (r == -1) {
1157 dev_err(&udev->dev,
1158 "ath9k_htc: Could not find bulk out endpoint\n");
1159 return -ENODEV;
1160 }
1161
1162 cmd = kzalloc(31, GFP_KERNEL);
1163 if (cmd == NULL)
1164 return -ENODEV;
1165
1166 /* USB bulk command block */
1167 cmd[0] = 0x55; /* bulk command signature */
1168 cmd[1] = 0x53; /* bulk command signature */
1169 cmd[2] = 0x42; /* bulk command signature */
1170 cmd[3] = 0x43; /* bulk command signature */
1171 cmd[14] = 6; /* command length */
1172
1173 cmd[15] = 0x1b; /* SCSI command: START STOP UNIT */
1174 cmd[19] = 0x2; /* eject disc */
1175
1176 dev_info(&udev->dev, "Ejecting storage device...\n");
1177 r = usb_bulk_msg(udev, usb_sndbulkpipe(udev, bulk_out_ep),
1178 cmd, 31, NULL, 2000);
1179 kfree(cmd);
1180 if (r)
1181 return r;
1182
1183 /* At this point, the device disconnects and reconnects with the real
1184 * ID numbers. */
1185
1186 usb_set_intfdata(interface, NULL);
1187 return 0;
1188}
1189
fb9987d0
S		 1190static int ath9k_hif_usb_probe(struct usb_interface *interface,
1191 const struct usb_device_id *id)
1192{
1193 struct usb_device *udev = interface_to_usbdev(interface);
1194 struct hif_device_usb *hif_dev;
fb9987d0
S		 1195 int ret = 0;
1196
36bcce43
SM		 1197 if (id->driver_info == STORAGE_DEVICE)
1198 return send_eject_command(interface);
1199
fb9987d0
S		 1200 hif_dev = kzalloc(sizeof(struct hif_device_usb), GFP_KERNEL);
1201 if (!hif_dev) {
1202 ret = -ENOMEM;
1203 goto err_alloc;
1204 }
1205
1206 usb_get_dev(udev);
0ed7b93e 1207
fb9987d0
S		 1208 hif_dev->udev = udev;
1209 hif_dev->interface = interface;
0ed7b93e 1210 hif_dev->usb_device_id = id;
fb9987d0
S		 1211#ifdef CONFIG_PM
1212 udev->reset_resume = 1;
1213#endif
1214 usb_set_intfdata(interface, hif_dev);
1215
0ed7b93e 1216 init_completion(&hif_dev->fw_done);
47fce026 1217
ce43cee5
S		 1218 /* Find out which firmware to load */
1219
0b5ead91 1220 if (IS_AR7010_DEVICE(id->driver_info))
9efabad2 1221 hif_dev->fw_name = FIRMWARE_AR7010_1_1;
fa6e15e0 1222 else
d0ee0ebe 1223 hif_dev->fw_name = FIRMWARE_AR9271;
ce43cee5 1224
0ed7b93e
SM		 1225 ret = request_firmware_nowait(THIS_MODULE, true, hif_dev->fw_name,
1226 &hif_dev->udev->dev, GFP_KERNEL,
1227 hif_dev, ath9k_hif_usb_firmware_cb);
fb9987d0 1228 if (ret) {
0ed7b93e
SM		 1229 dev_err(&hif_dev->udev->dev,
1230 "ath9k_htc: Async request for firmware %s failed\n",
1231 hif_dev->fw_name);
1232 goto err_fw_req;
fb9987d0
S		 1233 }
1234
0ed7b93e
SM		 1235 dev_info(&hif_dev->udev->dev, "ath9k_htc: Firmware %s requested\n",
1236 hif_dev->fw_name);
fb9987d0
S		 1237
1238 return 0;
1239
0ed7b93e 1240err_fw_req:
fb9987d0
S		 1241 usb_set_intfdata(interface, NULL);
1242 kfree(hif_dev);
1243 usb_put_dev(udev);
1244err_alloc:
1245 return ret;
1246}
1247
62e4716a
S		 1248static void ath9k_hif_usb_reboot(struct usb_device *udev)
1249{
1250 u32 reboot_cmd = 0xffffffff;
1251 void *buf;
1252 int ret;
1253
a465a2cc 1254 buf = kmemdup(&reboot_cmd, 4, GFP_KERNEL);
62e4716a
S		 1255 if (!buf)
1256 return;
1257
2b721118 1258 ret = usb_interrupt_msg(udev, usb_sndintpipe(udev, USB_REG_OUT_PIPE),
62e4716a
S		 1259 buf, 4, NULL, HZ);
1260 if (ret)
1261 dev_err(&udev->dev, "ath9k_htc: USB reboot failed\n");
1262
1263 kfree(buf);
1264}
1265
fb9987d0
S		 1266static void ath9k_hif_usb_disconnect(struct usb_interface *interface)
1267{
1268 struct usb_device *udev = interface_to_usbdev(interface);
b2767363 1269 struct hif_device_usb *hif_dev = usb_get_intfdata(interface);
97dcec57 1270 bool unplugged = (udev->state == USB_STATE_NOTATTACHED) ? true : false;
fb9987d0 1271
36bcce43
SM		 1272 if (!hif_dev)
1273 return;
1274
0ed7b93e
SM		 1275 wait_for_completion(&hif_dev->fw_done);
1276
32e31de5 1277 if (hif_dev->flags & HIF_USB_READY) {
0ed7b93e
SM		 1278 ath9k_htc_hw_deinit(hif_dev->htc_handle, unplugged);
1279 ath9k_htc_hw_free(hif_dev->htc_handle);
1280 ath9k_hif_usb_dev_deinit(hif_dev);
0ed7b93e
SM		 1281 }
1282
36bcce43 1283 usb_set_intfdata(interface, NULL);
fb9987d0 1284
4928bd2e
OR		 1285 /* If firmware was loaded we should drop it
1286 * go back to first stage bootloader. */
1287 if (!unplugged && (hif_dev->flags & HIF_USB_READY))
62e4716a 1288 ath9k_hif_usb_reboot(udev);
fb9987d0
S		 1289
1290 kfree(hif_dev);
1291 dev_info(&udev->dev, "ath9k_htc: USB layer deinitialized\n");
1292 usb_put_dev(udev);
1293}
1294
1295#ifdef CONFIG_PM
1296static int ath9k_hif_usb_suspend(struct usb_interface *interface,
1297 pm_message_t message)
1298{
b2767363 1299 struct hif_device_usb *hif_dev = usb_get_intfdata(interface);
fb9987d0 1300
f933ebed
SM		 1301 /*
1302 * The device has to be set to FULLSLEEP mode in case no
1303 * interface is up.
1304 */
1305 if (!(hif_dev->flags & HIF_USB_START))
1306 ath9k_htc_suspend(hif_dev->htc_handle);
1307
9494849e
AK		 1308 wait_for_completion(&hif_dev->fw_done);
1309
1310 if (hif_dev->flags & HIF_USB_READY)
1311 ath9k_hif_usb_dealloc_urbs(hif_dev);
fb9987d0
S		 1312
1313 return 0;
1314}
1315
1316static int ath9k_hif_usb_resume(struct usb_interface *interface)
1317{
b2767363 1318 struct hif_device_usb *hif_dev = usb_get_intfdata(interface);
fa6e15e0 1319 struct htc_target *htc_handle = hif_dev->htc_handle;
fb9987d0 1320 int ret;
32e31de5 1321 const struct firmware *fw;
fb9987d0
S		 1322
1323 ret = ath9k_hif_usb_alloc_urbs(hif_dev);
1324 if (ret)
1325 return ret;
1326
32e31de5
ML		 1327 if (hif_dev->flags & HIF_USB_READY) {
1328 /* request cached firmware during suspend/resume cycle */
1329 ret = request_firmware(&fw, hif_dev->fw_name,
1330 &hif_dev->udev->dev);
1331 if (ret)
1332 goto fail_resume;
1333
1334 hif_dev->fw_data = fw->data;
1335 hif_dev->fw_size = fw->size;
0ed7b93e 1336 ret = ath9k_hif_usb_download_fw(hif_dev);
32e31de5 1337 release_firmware(fw);
fb9987d0
S		 1338 if (ret)
1339 goto fail_resume;
1340 } else {
1341 ath9k_hif_usb_dealloc_urbs(hif_dev);
1342 return -EIO;
1343 }
1344
1345 mdelay(100);
1346
fa6e15e0 1347 ret = ath9k_htc_resume(htc_handle);
fb9987d0
S		 1348
1349 if (ret)
1350 goto fail_resume;
1351
1352 return 0;
1353
1354fail_resume:
1355 ath9k_hif_usb_dealloc_urbs(hif_dev);
1356
1357 return ret;
1358}
1359#endif
1360
1361static struct usb_driver ath9k_hif_usb_driver = {
50f68712 1362 .name = KBUILD_MODNAME,
fb9987d0
S		 1363 .probe = ath9k_hif_usb_probe,
1364 .disconnect = ath9k_hif_usb_disconnect,
1365#ifdef CONFIG_PM
1366 .suspend = ath9k_hif_usb_suspend,
1367 .resume = ath9k_hif_usb_resume,
1368 .reset_resume = ath9k_hif_usb_resume,
1369#endif
1370 .id_table = ath9k_hif_usb_ids,
1371 .soft_unbind = 1,
e1f12eb6 1372 .disable_hub_initiated_lpm = 1,
fb9987d0
S		 1373};
1374
1375int ath9k_hif_usb_init(void)
1376{
1377 return usb_register(&ath9k_hif_usb_driver);
1378}
1379
1380void ath9k_hif_usb_exit(void)
1381{
1382 usb_deregister(&ath9k_hif_usb_driver);
1383}
Linux kernel - Deliverables
This page took 0.571188 seconds and 5 git commands to generate.