1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17#include <linux/kernel.h>
18#include <linux/module.h>
19#include <linux/firmware.h>
20#include <linux/usb.h>
21#include <linux/vmalloc.h>
22
23#include <brcmu_utils.h>
24#include <brcm_hw_ids.h>
25#include <brcmu_wifi.h>
26#include "bus.h"
27#include "debug.h"
28#include "firmware.h"
29#include "usb.h"
30
31
32#define IOCTL_RESP_TIMEOUT msecs_to_jiffies(2000)
33
34#define BRCMF_USB_RESET_GETVER_SPINWAIT 100
35#define BRCMF_USB_RESET_GETVER_LOOP_CNT 10
36
37#define BRCMF_POSTBOOT_ID 0xA123
38
39#define BRCMF_USB_NRXQ 50
40#define BRCMF_USB_NTXQ 50
41
42#define BRCMF_USB_CBCTL_WRITE 0
43#define BRCMF_USB_CBCTL_READ 1
44#define BRCMF_USB_MAX_PKT_SIZE 1600
45
46BRCMF_FW_DEF(43143, "brcmfmac43143.bin");
47BRCMF_FW_DEF(43236B, "brcmfmac43236b.bin");
48BRCMF_FW_DEF(43242A, "brcmfmac43242a.bin");
49BRCMF_FW_DEF(43569, "brcmfmac43569.bin");
50
51static struct brcmf_firmware_mapping brcmf_usb_fwnames[] = {
52 BRCMF_FW_ENTRY(BRCM_CC_43143_CHIP_ID, 0xFFFFFFFF, 43143),
53 BRCMF_FW_ENTRY(BRCM_CC_43235_CHIP_ID, 0x00000008, 43236B),
54 BRCMF_FW_ENTRY(BRCM_CC_43236_CHIP_ID, 0x00000008, 43236B),
55 BRCMF_FW_ENTRY(BRCM_CC_43238_CHIP_ID, 0x00000008, 43236B),
56 BRCMF_FW_ENTRY(BRCM_CC_43242_CHIP_ID, 0xFFFFFFFF, 43242A),
57 BRCMF_FW_ENTRY(BRCM_CC_43566_CHIP_ID, 0xFFFFFFFF, 43569),
58 BRCMF_FW_ENTRY(BRCM_CC_43569_CHIP_ID, 0xFFFFFFFF, 43569)
59};
60
61#define TRX_MAGIC 0x30524448
62#define TRX_MAX_OFFSET 3
63#define TRX_UNCOMP_IMAGE 0x20
64#define TRX_RDL_CHUNK 1500
65#define TRX_OFFSETS_DLFWLEN_IDX 0
66
67
68#define DL_GETSTATE 0
69#define DL_CHECK_CRC 1
70#define DL_GO 2
71#define DL_START 3
72#define DL_REBOOT 4
73#define DL_GETVER 5
74#define DL_GO_PROTECTED 6
75
76
77
78
79#define DL_EXEC 7
80#define DL_RESETCFG 8
81
82
83#define DL_DEFER_RESP_OK 9
84
85
86
87
88#define DL_WAITING 0
89#define DL_READY 1
90
91
92#define DL_BAD_HDR 2
93#define DL_BAD_CRC 3
94#define DL_RUNNABLE 4
95#define DL_START_FAIL 5
96#define DL_NVRAM_TOOBIG 6
97
98
99#define DL_IMAGE_TOOBIG 7
100
101
102struct trx_header_le {
103 __le32 magic;
104 __le32 len;
105 __le32 crc32;
106 __le32 flag_version;
107 __le32 offsets[TRX_MAX_OFFSET];
108
109
110};
111
112struct rdl_state_le {
113 __le32 state;
114 __le32 bytes;
115};
116
117struct bootrom_id_le {
118 __le32 chip;
119 __le32 chiprev;
120 __le32 ramsize;
121 __le32 remapbase;
122 __le32 boardtype;
123 __le32 boardrev;
124};
125
126struct brcmf_usb_image {
127 struct list_head list;
128 s8 *fwname;
129 u8 *image;
130 int image_len;
131};
132
133struct brcmf_usbdev_info {
134 struct brcmf_usbdev bus_pub;
135 spinlock_t qlock;
136 struct list_head rx_freeq;
137 struct list_head rx_postq;
138 struct list_head tx_freeq;
139 struct list_head tx_postq;
140 uint rx_pipe, tx_pipe;
141
142 int rx_low_watermark;
143 int tx_low_watermark;
144 int tx_high_watermark;
145 int tx_freecount;
146 bool tx_flowblock;
147 spinlock_t tx_flowblock_lock;
148
149 struct brcmf_usbreq *tx_reqs;
150 struct brcmf_usbreq *rx_reqs;
151
152 char fw_name[BRCMF_FW_NAME_LEN];
153 const u8 *image;
154 int image_len;
155
156 struct usb_device *usbdev;
157 struct device *dev;
158 struct mutex dev_init_lock;
159
160 int ctl_in_pipe, ctl_out_pipe;
161 struct urb *ctl_urb;
162 struct usb_ctrlrequest ctl_write;
163 struct usb_ctrlrequest ctl_read;
164 u32 ctl_urb_actual_length;
165 int ctl_urb_status;
166 int ctl_completed;
167 wait_queue_head_t ioctl_resp_wait;
168 ulong ctl_op;
169 u8 ifnum;
170
171 struct urb *bulk_urb;
172
173 bool wowl_enabled;
174};
175
176static void brcmf_usb_rx_refill(struct brcmf_usbdev_info *devinfo,
177 struct brcmf_usbreq *req);
178
179static struct brcmf_usbdev *brcmf_usb_get_buspub(struct device *dev)
180{
181 struct brcmf_bus *bus_if = dev_get_drvdata(dev);
182 return bus_if->bus_priv.usb;
183}
184
185static struct brcmf_usbdev_info *brcmf_usb_get_businfo(struct device *dev)
186{
187 return brcmf_usb_get_buspub(dev)->devinfo;
188}
189
190static int brcmf_usb_ioctl_resp_wait(struct brcmf_usbdev_info *devinfo)
191{
192 return wait_event_timeout(devinfo->ioctl_resp_wait,
193 devinfo->ctl_completed, IOCTL_RESP_TIMEOUT);
194}
195
196static void brcmf_usb_ioctl_resp_wake(struct brcmf_usbdev_info *devinfo)
197{
198 wake_up(&devinfo->ioctl_resp_wait);
199}
200
201static void
202brcmf_usb_ctl_complete(struct brcmf_usbdev_info *devinfo, int type, int status)
203{
204 brcmf_dbg(USB, "Enter, status=%d\n", status);
205
206 if (unlikely(devinfo == NULL))
207 return;
208
209 if (type == BRCMF_USB_CBCTL_READ) {
210 if (status == 0)
211 devinfo->bus_pub.stats.rx_ctlpkts++;
212 else
213 devinfo->bus_pub.stats.rx_ctlerrs++;
214 } else if (type == BRCMF_USB_CBCTL_WRITE) {
215 if (status == 0)
216 devinfo->bus_pub.stats.tx_ctlpkts++;
217 else
218 devinfo->bus_pub.stats.tx_ctlerrs++;
219 }
220
221 devinfo->ctl_urb_status = status;
222 devinfo->ctl_completed = true;
223 brcmf_usb_ioctl_resp_wake(devinfo);
224}
225
226static void
227brcmf_usb_ctlread_complete(struct urb *urb)
228{
229 struct brcmf_usbdev_info *devinfo =
230 (struct brcmf_usbdev_info *)urb->context;
231
232 brcmf_dbg(USB, "Enter\n");
233 devinfo->ctl_urb_actual_length = urb->actual_length;
234 brcmf_usb_ctl_complete(devinfo, BRCMF_USB_CBCTL_READ,
235 urb->status);
236}
237
238static void
239brcmf_usb_ctlwrite_complete(struct urb *urb)
240{
241 struct brcmf_usbdev_info *devinfo =
242 (struct brcmf_usbdev_info *)urb->context;
243
244 brcmf_dbg(USB, "Enter\n");
245 brcmf_usb_ctl_complete(devinfo, BRCMF_USB_CBCTL_WRITE,
246 urb->status);
247}
248
249static int
250brcmf_usb_send_ctl(struct brcmf_usbdev_info *devinfo, u8 *buf, int len)
251{
252 int ret;
253 u16 size;
254
255 brcmf_dbg(USB, "Enter\n");
256 if (devinfo == NULL || buf == NULL ||
257 len == 0 || devinfo->ctl_urb == NULL)
258 return -EINVAL;
259
260 size = len;
261 devinfo->ctl_write.wLength = cpu_to_le16p(&size);
262 devinfo->ctl_urb->transfer_buffer_length = size;
263 devinfo->ctl_urb_status = 0;
264 devinfo->ctl_urb_actual_length = 0;
265
266 usb_fill_control_urb(devinfo->ctl_urb,
267 devinfo->usbdev,
268 devinfo->ctl_out_pipe,
269 (unsigned char *) &devinfo->ctl_write,
270 buf, size,
271 (usb_complete_t)brcmf_usb_ctlwrite_complete,
272 devinfo);
273
274 ret = usb_submit_urb(devinfo->ctl_urb, GFP_ATOMIC);
275 if (ret < 0)
276 brcmf_err("usb_submit_urb failed %d\n", ret);
277
278 return ret;
279}
280
281static int
282brcmf_usb_recv_ctl(struct brcmf_usbdev_info *devinfo, u8 *buf, int len)
283{
284 int ret;
285 u16 size;
286
287 brcmf_dbg(USB, "Enter\n");
288 if ((devinfo == NULL) || (buf == NULL) || (len == 0)
289 || (devinfo->ctl_urb == NULL))
290 return -EINVAL;
291
292 size = len;
293 devinfo->ctl_read.wLength = cpu_to_le16p(&size);
294 devinfo->ctl_urb->transfer_buffer_length = size;
295
296 devinfo->ctl_read.bRequestType = USB_DIR_IN
297 | USB_TYPE_CLASS | USB_RECIP_INTERFACE;
298 devinfo->ctl_read.bRequest = 1;
299
300 usb_fill_control_urb(devinfo->ctl_urb,
301 devinfo->usbdev,
302 devinfo->ctl_in_pipe,
303 (unsigned char *) &devinfo->ctl_read,
304 buf, size,
305 (usb_complete_t)brcmf_usb_ctlread_complete,
306 devinfo);
307
308 ret = usb_submit_urb(devinfo->ctl_urb, GFP_ATOMIC);
309 if (ret < 0)
310 brcmf_err("usb_submit_urb failed %d\n", ret);
311
312 return ret;
313}
314
315static int brcmf_usb_tx_ctlpkt(struct device *dev, u8 *buf, u32 len)
316{
317 int err = 0;
318 int timeout = 0;
319 struct brcmf_usbdev_info *devinfo = brcmf_usb_get_businfo(dev);
320
321 brcmf_dbg(USB, "Enter\n");
322 if (devinfo->bus_pub.state != BRCMFMAC_USB_STATE_UP)
323 return -EIO;
324
325 if (test_and_set_bit(0, &devinfo->ctl_op))
326 return -EIO;
327
328 devinfo->ctl_completed = false;
329 err = brcmf_usb_send_ctl(devinfo, buf, len);
330 if (err) {
331 brcmf_err("fail %d bytes: %d\n", err, len);
332 clear_bit(0, &devinfo->ctl_op);
333 return err;
334 }
335 timeout = brcmf_usb_ioctl_resp_wait(devinfo);
336 clear_bit(0, &devinfo->ctl_op);
337 if (!timeout) {
338 brcmf_err("Txctl wait timed out\n");
339 err = -EIO;
340 }
341 return err;
342}
343
344static int brcmf_usb_rx_ctlpkt(struct device *dev, u8 *buf, u32 len)
345{
346 int err = 0;
347 int timeout = 0;
348 struct brcmf_usbdev_info *devinfo = brcmf_usb_get_businfo(dev);
349
350 brcmf_dbg(USB, "Enter\n");
351 if (devinfo->bus_pub.state != BRCMFMAC_USB_STATE_UP)
352 return -EIO;
353
354 if (test_and_set_bit(0, &devinfo->ctl_op))
355 return -EIO;
356
357 devinfo->ctl_completed = false;
358 err = brcmf_usb_recv_ctl(devinfo, buf, len);
359 if (err) {
360 brcmf_err("fail %d bytes: %d\n", err, len);
361 clear_bit(0, &devinfo->ctl_op);
362 return err;
363 }
364 timeout = brcmf_usb_ioctl_resp_wait(devinfo);
365 err = devinfo->ctl_urb_status;
366 clear_bit(0, &devinfo->ctl_op);
367 if (!timeout) {
368 brcmf_err("rxctl wait timed out\n");
369 err = -EIO;
370 }
371 if (!err)
372 return devinfo->ctl_urb_actual_length;
373 else
374 return err;
375}
376
377static struct brcmf_usbreq *brcmf_usb_deq(struct brcmf_usbdev_info *devinfo,
378 struct list_head *q, int *counter)
379{
380 unsigned long flags;
381 struct brcmf_usbreq *req;
382 spin_lock_irqsave(&devinfo->qlock, flags);
383 if (list_empty(q)) {
384 spin_unlock_irqrestore(&devinfo->qlock, flags);
385 return NULL;
386 }
387 req = list_entry(q->next, struct brcmf_usbreq, list);
388 list_del_init(q->next);
389 if (counter)
390 (*counter)--;
391 spin_unlock_irqrestore(&devinfo->qlock, flags);
392 return req;
393
394}
395
396static void brcmf_usb_enq(struct brcmf_usbdev_info *devinfo,
397 struct list_head *q, struct brcmf_usbreq *req,
398 int *counter)
399{
400 unsigned long flags;
401 spin_lock_irqsave(&devinfo->qlock, flags);
402 list_add_tail(&req->list, q);
403 if (counter)
404 (*counter)++;
405 spin_unlock_irqrestore(&devinfo->qlock, flags);
406}
407
408static struct brcmf_usbreq *
409brcmf_usbdev_qinit(struct list_head *q, int qsize)
410{
411 int i;
412 struct brcmf_usbreq *req, *reqs;
413
414 reqs = kcalloc(qsize, sizeof(struct brcmf_usbreq), GFP_ATOMIC);
415 if (reqs == NULL)
416 return NULL;
417
418 req = reqs;
419
420 for (i = 0; i < qsize; i++) {
421 req->urb = usb_alloc_urb(0, GFP_ATOMIC);
422 if (!req->urb)
423 goto fail;
424
425 INIT_LIST_HEAD(&req->list);
426 list_add_tail(&req->list, q);
427 req++;
428 }
429 return reqs;
430fail:
431 brcmf_err("fail!\n");
432 while (!list_empty(q)) {
433 req = list_entry(q->next, struct brcmf_usbreq, list);
434 if (req)
435 usb_free_urb(req->urb);
436 list_del(q->next);
437 }
438 return NULL;
439
440}
441
442static void brcmf_usb_free_q(struct list_head *q, bool pending)
443{
444 struct brcmf_usbreq *req, *next;
445 int i = 0;
446 list_for_each_entry_safe(req, next, q, list) {
447 if (!req->urb) {
448 brcmf_err("bad req\n");
449 break;
450 }
451 i++;
452 if (pending) {
453 usb_kill_urb(req->urb);
454 } else {
455 usb_free_urb(req->urb);
456 list_del_init(&req->list);
457 }
458 }
459}
460
461static void brcmf_usb_del_fromq(struct brcmf_usbdev_info *devinfo,
462 struct brcmf_usbreq *req)
463{
464 unsigned long flags;
465
466 spin_lock_irqsave(&devinfo->qlock, flags);
467 list_del_init(&req->list);
468 spin_unlock_irqrestore(&devinfo->qlock, flags);
469}
470
471
472static void brcmf_usb_tx_complete(struct urb *urb)
473{
474 struct brcmf_usbreq *req = (struct brcmf_usbreq *)urb->context;
475 struct brcmf_usbdev_info *devinfo = req->devinfo;
476 unsigned long flags;
477
478 brcmf_dbg(USB, "Enter, urb->status=%d, skb=%p\n", urb->status,
479 req->skb);
480 brcmf_usb_del_fromq(devinfo, req);
481
482 brcmf_txcomplete(devinfo->dev, req->skb, urb->status == 0);
483 req->skb = NULL;
484 brcmf_usb_enq(devinfo, &devinfo->tx_freeq, req, &devinfo->tx_freecount);
485 spin_lock_irqsave(&devinfo->tx_flowblock_lock, flags);
486 if (devinfo->tx_freecount > devinfo->tx_high_watermark &&
487 devinfo->tx_flowblock) {
488 brcmf_txflowblock(devinfo->dev, false);
489 devinfo->tx_flowblock = false;
490 }
491 spin_unlock_irqrestore(&devinfo->tx_flowblock_lock, flags);
492}
493
494static void brcmf_usb_rx_complete(struct urb *urb)
495{
496 struct brcmf_usbreq *req = (struct brcmf_usbreq *)urb->context;
497 struct brcmf_usbdev_info *devinfo = req->devinfo;
498 struct sk_buff *skb;
499
500 brcmf_dbg(USB, "Enter, urb->status=%d\n", urb->status);
501 brcmf_usb_del_fromq(devinfo, req);
502 skb = req->skb;
503 req->skb = NULL;
504
505
506 if (urb->status != 0 || !urb->actual_length) {
507 brcmu_pkt_buf_free_skb(skb);
508 brcmf_usb_enq(devinfo, &devinfo->rx_freeq, req, NULL);
509 return;
510 }
511
512 if (devinfo->bus_pub.state == BRCMFMAC_USB_STATE_UP) {
513 skb_put(skb, urb->actual_length);
514 brcmf_rx_frame(devinfo->dev, skb);
515 brcmf_usb_rx_refill(devinfo, req);
516 } else {
517 brcmu_pkt_buf_free_skb(skb);
518 brcmf_usb_enq(devinfo, &devinfo->rx_freeq, req, NULL);
519 }
520 return;
521
522}
523
524static void brcmf_usb_rx_refill(struct brcmf_usbdev_info *devinfo,
525 struct brcmf_usbreq *req)
526{
527 struct sk_buff *skb;
528 int ret;
529
530 if (!req || !devinfo)
531 return;
532
533 skb = dev_alloc_skb(devinfo->bus_pub.bus_mtu);
534 if (!skb) {
535 brcmf_usb_enq(devinfo, &devinfo->rx_freeq, req, NULL);
536 return;
537 }
538 req->skb = skb;
539
540 usb_fill_bulk_urb(req->urb, devinfo->usbdev, devinfo->rx_pipe,
541 skb->data, skb_tailroom(skb), brcmf_usb_rx_complete,
542 req);
543 req->devinfo = devinfo;
544 brcmf_usb_enq(devinfo, &devinfo->rx_postq, req, NULL);
545
546 ret = usb_submit_urb(req->urb, GFP_ATOMIC);
547 if (ret) {
548 brcmf_usb_del_fromq(devinfo, req);
549 brcmu_pkt_buf_free_skb(req->skb);
550 req->skb = NULL;
551 brcmf_usb_enq(devinfo, &devinfo->rx_freeq, req, NULL);
552 }
553 return;
554}
555
556static void brcmf_usb_rx_fill_all(struct brcmf_usbdev_info *devinfo)
557{
558 struct brcmf_usbreq *req;
559
560 if (devinfo->bus_pub.state != BRCMFMAC_USB_STATE_UP) {
561 brcmf_err("bus is not up=%d\n", devinfo->bus_pub.state);
562 return;
563 }
564 while ((req = brcmf_usb_deq(devinfo, &devinfo->rx_freeq, NULL)) != NULL)
565 brcmf_usb_rx_refill(devinfo, req);
566}
567
568static void
569brcmf_usb_state_change(struct brcmf_usbdev_info *devinfo, int state)
570{
571 struct brcmf_bus *bcmf_bus = devinfo->bus_pub.bus;
572 int old_state;
573
574 brcmf_dbg(USB, "Enter, current state=%d, new state=%d\n",
575 devinfo->bus_pub.state, state);
576
577 if (devinfo->bus_pub.state == state)
578 return;
579
580 old_state = devinfo->bus_pub.state;
581 devinfo->bus_pub.state = state;
582
583
584 if (state == BRCMFMAC_USB_STATE_DOWN) {
585 brcmf_dbg(USB, "DBUS is down\n");
586 brcmf_bus_change_state(bcmf_bus, BRCMF_BUS_DOWN);
587 } else if (state == BRCMFMAC_USB_STATE_UP) {
588 brcmf_dbg(USB, "DBUS is up\n");
589 brcmf_bus_change_state(bcmf_bus, BRCMF_BUS_UP);
590 } else {
591 brcmf_dbg(USB, "DBUS current state=%d\n", state);
592 }
593}
594
595static int brcmf_usb_tx(struct device *dev, struct sk_buff *skb)
596{
597 struct brcmf_usbdev_info *devinfo = brcmf_usb_get_businfo(dev);
598 struct brcmf_usbreq *req;
599 int ret;
600 unsigned long flags;
601
602 brcmf_dbg(USB, "Enter, skb=%p\n", skb);
603 if (devinfo->bus_pub.state != BRCMFMAC_USB_STATE_UP) {
604 ret = -EIO;
605 goto fail;
606 }
607
608 req = brcmf_usb_deq(devinfo, &devinfo->tx_freeq,
609 &devinfo->tx_freecount);
610 if (!req) {
611 brcmf_err("no req to send\n");
612 ret = -ENOMEM;
613 goto fail;
614 }
615
616 req->skb = skb;
617 req->devinfo = devinfo;
618 usb_fill_bulk_urb(req->urb, devinfo->usbdev, devinfo->tx_pipe,
619 skb->data, skb->len, brcmf_usb_tx_complete, req);
620 req->urb->transfer_flags |= URB_ZERO_PACKET;
621 brcmf_usb_enq(devinfo, &devinfo->tx_postq, req, NULL);
622 ret = usb_submit_urb(req->urb, GFP_ATOMIC);
623 if (ret) {
624 brcmf_err("brcmf_usb_tx usb_submit_urb FAILED\n");
625 brcmf_usb_del_fromq(devinfo, req);
626 req->skb = NULL;
627 brcmf_usb_enq(devinfo, &devinfo->tx_freeq, req,
628 &devinfo->tx_freecount);
629 goto fail;
630 }
631
632 spin_lock_irqsave(&devinfo->tx_flowblock_lock, flags);
633 if (devinfo->tx_freecount < devinfo->tx_low_watermark &&
634 !devinfo->tx_flowblock) {
635 brcmf_txflowblock(dev, true);
636 devinfo->tx_flowblock = true;
637 }
638 spin_unlock_irqrestore(&devinfo->tx_flowblock_lock, flags);
639 return 0;
640
641fail:
642 return ret;
643}
644
645
646static int brcmf_usb_up(struct device *dev)
647{
648 struct brcmf_usbdev_info *devinfo = brcmf_usb_get_businfo(dev);
649
650 brcmf_dbg(USB, "Enter\n");
651 if (devinfo->bus_pub.state == BRCMFMAC_USB_STATE_UP)
652 return 0;
653
654
655 brcmf_usb_state_change(devinfo, BRCMFMAC_USB_STATE_UP);
656
657 if (devinfo->ctl_urb) {
658 devinfo->ctl_in_pipe = usb_rcvctrlpipe(devinfo->usbdev, 0);
659 devinfo->ctl_out_pipe = usb_sndctrlpipe(devinfo->usbdev, 0);
660
661
662 devinfo->ctl_write.bRequestType =
663 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE;
664 devinfo->ctl_write.bRequest = 0;
665 devinfo->ctl_write.wValue = cpu_to_le16(0);
666 devinfo->ctl_write.wIndex = cpu_to_le16(devinfo->ifnum);
667
668
669 devinfo->ctl_read.bRequestType =
670 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE;
671 devinfo->ctl_read.bRequest = 1;
672 devinfo->ctl_read.wValue = cpu_to_le16(0);
673 devinfo->ctl_read.wIndex = cpu_to_le16(devinfo->ifnum);
674 }
675 brcmf_usb_rx_fill_all(devinfo);
676 return 0;
677}
678
679static void brcmf_cancel_all_urbs(struct brcmf_usbdev_info *devinfo)
680{
681 if (devinfo->ctl_urb)
682 usb_kill_urb(devinfo->ctl_urb);
683 if (devinfo->bulk_urb)
684 usb_kill_urb(devinfo->bulk_urb);
685 brcmf_usb_free_q(&devinfo->tx_postq, true);
686 brcmf_usb_free_q(&devinfo->rx_postq, true);
687}
688
689static void brcmf_usb_down(struct device *dev)
690{
691 struct brcmf_usbdev_info *devinfo = brcmf_usb_get_businfo(dev);
692
693 brcmf_dbg(USB, "Enter\n");
694 if (devinfo == NULL)
695 return;
696
697 if (devinfo->bus_pub.state == BRCMFMAC_USB_STATE_DOWN)
698 return;
699
700 brcmf_usb_state_change(devinfo, BRCMFMAC_USB_STATE_DOWN);
701
702 brcmf_cancel_all_urbs(devinfo);
703}
704
705static void
706brcmf_usb_sync_complete(struct urb *urb)
707{
708 struct brcmf_usbdev_info *devinfo =
709 (struct brcmf_usbdev_info *)urb->context;
710
711 devinfo->ctl_completed = true;
712 brcmf_usb_ioctl_resp_wake(devinfo);
713}
714
715static int brcmf_usb_dl_cmd(struct brcmf_usbdev_info *devinfo, u8 cmd,
716 void *buffer, int buflen)
717{
718 int ret;
719 char *tmpbuf;
720 u16 size;
721
722 if ((!devinfo) || (devinfo->ctl_urb == NULL))
723 return -EINVAL;
724
725 tmpbuf = kmalloc(buflen, GFP_ATOMIC);
726 if (!tmpbuf)
727 return -ENOMEM;
728
729 size = buflen;
730 devinfo->ctl_urb->transfer_buffer_length = size;
731
732 devinfo->ctl_read.wLength = cpu_to_le16p(&size);
733 devinfo->ctl_read.bRequestType = USB_DIR_IN | USB_TYPE_VENDOR |
734 USB_RECIP_INTERFACE;
735 devinfo->ctl_read.bRequest = cmd;
736
737 usb_fill_control_urb(devinfo->ctl_urb,
738 devinfo->usbdev,
739 usb_rcvctrlpipe(devinfo->usbdev, 0),
740 (unsigned char *) &devinfo->ctl_read,
741 (void *) tmpbuf, size,
742 (usb_complete_t)brcmf_usb_sync_complete, devinfo);
743
744 devinfo->ctl_completed = false;
745 ret = usb_submit_urb(devinfo->ctl_urb, GFP_ATOMIC);
746 if (ret < 0) {
747 brcmf_err("usb_submit_urb failed %d\n", ret);
748 goto finalize;
749 }
750
751 if (!brcmf_usb_ioctl_resp_wait(devinfo)) {
752 usb_kill_urb(devinfo->ctl_urb);
753 ret = -ETIMEDOUT;
754 } else {
755 memcpy(buffer, tmpbuf, buflen);
756 }
757
758finalize:
759 kfree(tmpbuf);
760 return ret;
761}
762
763static bool
764brcmf_usb_dlneeded(struct brcmf_usbdev_info *devinfo)
765{
766 struct bootrom_id_le id;
767 u32 chipid, chiprev;
768
769 brcmf_dbg(USB, "Enter\n");
770
771 if (devinfo == NULL)
772 return false;
773
774
775 id.chip = cpu_to_le32(0xDEAD);
776 brcmf_usb_dl_cmd(devinfo, DL_GETVER, &id, sizeof(id));
777
778 chipid = le32_to_cpu(id.chip);
779 chiprev = le32_to_cpu(id.chiprev);
780
781 if ((chipid & 0x4300) == 0x4300)
782 brcmf_dbg(USB, "chip %x rev 0x%x\n", chipid, chiprev);
783 else
784 brcmf_dbg(USB, "chip %d rev 0x%x\n", chipid, chiprev);
785 if (chipid == BRCMF_POSTBOOT_ID) {
786 brcmf_dbg(USB, "firmware already downloaded\n");
787 brcmf_usb_dl_cmd(devinfo, DL_RESETCFG, &id, sizeof(id));
788 return false;
789 } else {
790 devinfo->bus_pub.devid = chipid;
791 devinfo->bus_pub.chiprev = chiprev;
792 }
793 return true;
794}
795
796static int
797brcmf_usb_resetcfg(struct brcmf_usbdev_info *devinfo)
798{
799 struct bootrom_id_le id;
800 u32 loop_cnt;
801 int err;
802
803 brcmf_dbg(USB, "Enter\n");
804
805 loop_cnt = 0;
806 do {
807 mdelay(BRCMF_USB_RESET_GETVER_SPINWAIT);
808 loop_cnt++;
809 id.chip = cpu_to_le32(0xDEAD);
810 err = brcmf_usb_dl_cmd(devinfo, DL_GETVER, &id, sizeof(id));
811 if ((err) && (err != -ETIMEDOUT))
812 return err;
813 if (id.chip == cpu_to_le32(BRCMF_POSTBOOT_ID))
814 break;
815 } while (loop_cnt < BRCMF_USB_RESET_GETVER_LOOP_CNT);
816
817 if (id.chip == cpu_to_le32(BRCMF_POSTBOOT_ID)) {
818 brcmf_dbg(USB, "postboot chip 0x%x/rev 0x%x\n",
819 le32_to_cpu(id.chip), le32_to_cpu(id.chiprev));
820
821 brcmf_usb_dl_cmd(devinfo, DL_RESETCFG, &id, sizeof(id));
822 return 0;
823 } else {
824 brcmf_err("Cannot talk to Dongle. Firmware is not UP, %d ms\n",
825 BRCMF_USB_RESET_GETVER_SPINWAIT * loop_cnt);
826 return -EINVAL;
827 }
828}
829
830
831static int
832brcmf_usb_dl_send_bulk(struct brcmf_usbdev_info *devinfo, void *buffer, int len)
833{
834 int ret;
835
836 if ((devinfo == NULL) || (devinfo->bulk_urb == NULL))
837 return -EINVAL;
838
839
840 usb_fill_bulk_urb(devinfo->bulk_urb, devinfo->usbdev,
841 devinfo->tx_pipe, buffer, len,
842 (usb_complete_t)brcmf_usb_sync_complete, devinfo);
843
844 devinfo->bulk_urb->transfer_flags |= URB_ZERO_PACKET;
845
846 devinfo->ctl_completed = false;
847 ret = usb_submit_urb(devinfo->bulk_urb, GFP_ATOMIC);
848 if (ret) {
849 brcmf_err("usb_submit_urb failed %d\n", ret);
850 return ret;
851 }
852 ret = brcmf_usb_ioctl_resp_wait(devinfo);
853 return (ret == 0);
854}
855
856static int
857brcmf_usb_dl_writeimage(struct brcmf_usbdev_info *devinfo, u8 *fw, int fwlen)
858{
859 unsigned int sendlen, sent, dllen;
860 char *bulkchunk = NULL, *dlpos;
861 struct rdl_state_le state;
862 u32 rdlstate, rdlbytes;
863 int err = 0;
864
865 brcmf_dbg(USB, "Enter, fw %p, len %d\n", fw, fwlen);
866
867 bulkchunk = kmalloc(TRX_RDL_CHUNK, GFP_ATOMIC);
868 if (bulkchunk == NULL) {
869 err = -ENOMEM;
870 goto fail;
871 }
872
873
874 brcmf_usb_dl_cmd(devinfo, DL_START, &state, sizeof(state));
875
876 rdlstate = le32_to_cpu(state.state);
877 rdlbytes = le32_to_cpu(state.bytes);
878
879
880 if (rdlstate != DL_WAITING) {
881 brcmf_err("Failed to DL_START\n");
882 err = -EINVAL;
883 goto fail;
884 }
885 sent = 0;
886 dlpos = fw;
887 dllen = fwlen;
888
889
890 while (rdlbytes != dllen) {
891
892
893 if ((rdlbytes == sent) && (rdlbytes != dllen)) {
894 if ((dllen-sent) < TRX_RDL_CHUNK)
895 sendlen = dllen-sent;
896 else
897 sendlen = TRX_RDL_CHUNK;
898
899
900
901
902
903 if (!(sendlen % 64))
904 sendlen -= 4;
905
906
907 memcpy(bulkchunk, dlpos, sendlen);
908 if (brcmf_usb_dl_send_bulk(devinfo, bulkchunk,
909 sendlen)) {
910 brcmf_err("send_bulk failed\n");
911 err = -EINVAL;
912 goto fail;
913 }
914
915 dlpos += sendlen;
916 sent += sendlen;
917 }
918 err = brcmf_usb_dl_cmd(devinfo, DL_GETSTATE, &state,
919 sizeof(state));
920 if (err) {
921 brcmf_err("DL_GETSTATE Failed\n");
922 goto fail;
923 }
924
925 rdlstate = le32_to_cpu(state.state);
926 rdlbytes = le32_to_cpu(state.bytes);
927
928
929 if (rdlstate == DL_BAD_HDR || rdlstate == DL_BAD_CRC) {
930 brcmf_err("Bad Hdr or Bad CRC state %d\n",
931 rdlstate);
932 err = -EINVAL;
933 goto fail;
934 }
935 }
936
937fail:
938 kfree(bulkchunk);
939 brcmf_dbg(USB, "Exit, err=%d\n", err);
940 return err;
941}
942
943static int brcmf_usb_dlstart(struct brcmf_usbdev_info *devinfo, u8 *fw, int len)
944{
945 int err;
946
947 brcmf_dbg(USB, "Enter\n");
948
949 if (devinfo == NULL)
950 return -EINVAL;
951
952 if (devinfo->bus_pub.devid == 0xDEAD)
953 return -EINVAL;
954
955 err = brcmf_usb_dl_writeimage(devinfo, fw, len);
956 if (err == 0)
957 devinfo->bus_pub.state = BRCMFMAC_USB_STATE_DL_DONE;
958 else
959 devinfo->bus_pub.state = BRCMFMAC_USB_STATE_DL_FAIL;
960 brcmf_dbg(USB, "Exit, err=%d\n", err);
961
962 return err;
963}
964
965static int brcmf_usb_dlrun(struct brcmf_usbdev_info *devinfo)
966{
967 struct rdl_state_le state;
968
969 brcmf_dbg(USB, "Enter\n");
970 if (!devinfo)
971 return -EINVAL;
972
973 if (devinfo->bus_pub.devid == 0xDEAD)
974 return -EINVAL;
975
976
977 state.state = 0;
978 brcmf_usb_dl_cmd(devinfo, DL_GETSTATE, &state, sizeof(state));
979
980
981 if (state.state == cpu_to_le32(DL_RUNNABLE)) {
982 if (brcmf_usb_dl_cmd(devinfo, DL_GO, &state, sizeof(state)))
983 return -ENODEV;
984 if (brcmf_usb_resetcfg(devinfo))
985 return -ENODEV;
986
987 } else {
988 brcmf_err("Dongle not runnable\n");
989 return -EINVAL;
990 }
991 brcmf_dbg(USB, "Exit\n");
992 return 0;
993}
994
995static int
996brcmf_usb_fw_download(struct brcmf_usbdev_info *devinfo)
997{
998 int err;
999
1000 brcmf_dbg(USB, "Enter\n");
1001 if (devinfo == NULL)
1002 return -ENODEV;
1003
1004 if (!devinfo->image) {
1005 brcmf_err("No firmware!\n");
1006 return -ENOENT;
1007 }
1008
1009 err = brcmf_usb_dlstart(devinfo,
1010 (u8 *)devinfo->image, devinfo->image_len);
1011 if (err == 0)
1012 err = brcmf_usb_dlrun(devinfo);
1013 return err;
1014}
1015
1016
1017static void brcmf_usb_detach(struct brcmf_usbdev_info *devinfo)
1018{
1019 brcmf_dbg(USB, "Enter, devinfo %p\n", devinfo);
1020
1021
1022 brcmf_usb_free_q(&devinfo->rx_freeq, false);
1023 brcmf_usb_free_q(&devinfo->tx_freeq, false);
1024
1025 usb_free_urb(devinfo->ctl_urb);
1026 usb_free_urb(devinfo->bulk_urb);
1027
1028 kfree(devinfo->tx_reqs);
1029 kfree(devinfo->rx_reqs);
1030}
1031
1032
1033static int check_file(const u8 *headers)
1034{
1035 struct trx_header_le *trx;
1036 int actual_len = -1;
1037
1038 brcmf_dbg(USB, "Enter\n");
1039
1040 trx = (struct trx_header_le *) headers;
1041 if (trx->magic != cpu_to_le32(TRX_MAGIC))
1042 return -1;
1043
1044 headers += sizeof(struct trx_header_le);
1045
1046 if (le32_to_cpu(trx->flag_version) & TRX_UNCOMP_IMAGE) {
1047 actual_len = le32_to_cpu(trx->offsets[TRX_OFFSETS_DLFWLEN_IDX]);
1048 return actual_len + sizeof(struct trx_header_le);
1049 }
1050 return -1;
1051}
1052
1053
1054static
1055struct brcmf_usbdev *brcmf_usb_attach(struct brcmf_usbdev_info *devinfo,
1056 int nrxq, int ntxq)
1057{
1058 brcmf_dbg(USB, "Enter\n");
1059
1060 devinfo->bus_pub.nrxq = nrxq;
1061 devinfo->rx_low_watermark = nrxq / 2;
1062 devinfo->bus_pub.devinfo = devinfo;
1063 devinfo->bus_pub.ntxq = ntxq;
1064 devinfo->bus_pub.state = BRCMFMAC_USB_STATE_DOWN;
1065
1066
1067 devinfo->tx_low_watermark = ntxq / 4;
1068 devinfo->tx_high_watermark = devinfo->tx_low_watermark * 3;
1069 devinfo->bus_pub.bus_mtu = BRCMF_USB_MAX_PKT_SIZE;
1070
1071
1072 init_waitqueue_head(&devinfo->ioctl_resp_wait);
1073
1074
1075 spin_lock_init(&devinfo->qlock);
1076 spin_lock_init(&devinfo->tx_flowblock_lock);
1077
1078 INIT_LIST_HEAD(&devinfo->rx_freeq);
1079 INIT_LIST_HEAD(&devinfo->rx_postq);
1080
1081 INIT_LIST_HEAD(&devinfo->tx_freeq);
1082 INIT_LIST_HEAD(&devinfo->tx_postq);
1083
1084 devinfo->tx_flowblock = false;
1085
1086 devinfo->rx_reqs = brcmf_usbdev_qinit(&devinfo->rx_freeq, nrxq);
1087 if (!devinfo->rx_reqs)
1088 goto error;
1089
1090 devinfo->tx_reqs = brcmf_usbdev_qinit(&devinfo->tx_freeq, ntxq);
1091 if (!devinfo->tx_reqs)
1092 goto error;
1093 devinfo->tx_freecount = ntxq;
1094
1095 devinfo->ctl_urb = usb_alloc_urb(0, GFP_ATOMIC);
1096 if (!devinfo->ctl_urb) {
1097 brcmf_err("usb_alloc_urb (ctl) failed\n");
1098 goto error;
1099 }
1100 devinfo->bulk_urb = usb_alloc_urb(0, GFP_ATOMIC);
1101 if (!devinfo->bulk_urb) {
1102 brcmf_err("usb_alloc_urb (bulk) failed\n");
1103 goto error;
1104 }
1105
1106 return &devinfo->bus_pub;
1107
1108error:
1109 brcmf_err("failed!\n");
1110 brcmf_usb_detach(devinfo);
1111 return NULL;
1112}
1113
1114static void brcmf_usb_wowl_config(struct device *dev, bool enabled)
1115{
1116 struct brcmf_usbdev_info *devinfo = brcmf_usb_get_businfo(dev);
1117
1118 brcmf_dbg(USB, "Configuring WOWL, enabled=%d\n", enabled);
1119 devinfo->wowl_enabled = enabled;
1120 if (enabled)
1121 device_set_wakeup_enable(devinfo->dev, true);
1122 else
1123 device_set_wakeup_enable(devinfo->dev, false);
1124}
1125
1126static const struct brcmf_bus_ops brcmf_usb_bus_ops = {
1127 .txdata = brcmf_usb_tx,
1128 .stop = brcmf_usb_down,
1129 .txctl = brcmf_usb_tx_ctlpkt,
1130 .rxctl = brcmf_usb_rx_ctlpkt,
1131 .wowl_config = brcmf_usb_wowl_config,
1132};
1133
1134static int brcmf_usb_bus_setup(struct brcmf_usbdev_info *devinfo)
1135{
1136 int ret;
1137
1138
1139 ret = brcmf_attach(devinfo->dev);
1140 if (ret) {
1141 brcmf_err("brcmf_attach failed\n");
1142 return ret;
1143 }
1144
1145 ret = brcmf_usb_up(devinfo->dev);
1146 if (ret)
1147 goto fail;
1148
1149 ret = brcmf_bus_start(devinfo->dev);
1150 if (ret)
1151 goto fail;
1152
1153 return 0;
1154fail:
1155 brcmf_detach(devinfo->dev);
1156 return ret;
1157}
1158
1159static void brcmf_usb_probe_phase2(struct device *dev,
1160 const struct firmware *fw,
1161 void *nvram, u32 nvlen)
1162{
1163 struct brcmf_bus *bus = dev_get_drvdata(dev);
1164 struct brcmf_usbdev_info *devinfo;
1165 int ret;
1166
1167 brcmf_dbg(USB, "Start fw downloading\n");
1168
1169 devinfo = bus->bus_priv.usb->devinfo;
1170 ret = check_file(fw->data);
1171 if (ret < 0) {
1172 brcmf_err("invalid firmware\n");
1173 release_firmware(fw);
1174 goto error;
1175 }
1176
1177 devinfo->image = fw->data;
1178 devinfo->image_len = fw->size;
1179
1180 ret = brcmf_usb_fw_download(devinfo);
1181 release_firmware(fw);
1182 if (ret)
1183 goto error;
1184
1185 ret = brcmf_usb_bus_setup(devinfo);
1186 if (ret)
1187 goto error;
1188
1189 mutex_unlock(&devinfo->dev_init_lock);
1190 return;
1191error:
1192 brcmf_dbg(TRACE, "failed: dev=%s, err=%d\n", dev_name(dev), ret);
1193 mutex_unlock(&devinfo->dev_init_lock);
1194 device_release_driver(dev);
1195}
1196
1197static int brcmf_usb_probe_cb(struct brcmf_usbdev_info *devinfo)
1198{
1199 struct brcmf_bus *bus = NULL;
1200 struct brcmf_usbdev *bus_pub = NULL;
1201 struct device *dev = devinfo->dev;
1202 int ret;
1203
1204 brcmf_dbg(USB, "Enter\n");
1205 bus_pub = brcmf_usb_attach(devinfo, BRCMF_USB_NRXQ, BRCMF_USB_NTXQ);
1206 if (!bus_pub)
1207 return -ENODEV;
1208
1209 bus = kzalloc(sizeof(struct brcmf_bus), GFP_ATOMIC);
1210 if (!bus) {
1211 ret = -ENOMEM;
1212 goto fail;
1213 }
1214
1215 bus->dev = dev;
1216 bus_pub->bus = bus;
1217 bus->bus_priv.usb = bus_pub;
1218 dev_set_drvdata(dev, bus);
1219 bus->ops = &brcmf_usb_bus_ops;
1220 bus->proto_type = BRCMF_PROTO_BCDC;
1221 bus->always_use_fws_queue = true;
1222#ifdef CONFIG_PM
1223 bus->wowl_supported = true;
1224#endif
1225
1226 if (!brcmf_usb_dlneeded(devinfo)) {
1227 ret = brcmf_usb_bus_setup(devinfo);
1228 if (ret)
1229 goto fail;
1230
1231 mutex_unlock(&devinfo->dev_init_lock);
1232 return 0;
1233 }
1234 bus->chip = bus_pub->devid;
1235 bus->chiprev = bus_pub->chiprev;
1236
1237 ret = brcmf_fw_map_chip_to_name(bus_pub->devid, bus_pub->chiprev,
1238 brcmf_usb_fwnames,
1239 ARRAY_SIZE(brcmf_usb_fwnames),
1240 devinfo->fw_name, NULL);
1241 if (ret)
1242 goto fail;
1243
1244
1245 ret = brcmf_fw_get_firmwares(dev, 0, devinfo->fw_name, NULL,
1246 brcmf_usb_probe_phase2);
1247 if (ret) {
1248 brcmf_err("firmware request failed: %d\n", ret);
1249 goto fail;
1250 }
1251
1252 return 0;
1253
1254fail:
1255
1256 kfree(bus);
1257 brcmf_usb_detach(devinfo);
1258 return ret;
1259}
1260
1261static void
1262brcmf_usb_disconnect_cb(struct brcmf_usbdev_info *devinfo)
1263{
1264 if (!devinfo)
1265 return;
1266 brcmf_dbg(USB, "Enter, bus_pub %p\n", devinfo);
1267
1268 brcmf_detach(devinfo->dev);
1269 kfree(devinfo->bus_pub.bus);
1270 brcmf_usb_detach(devinfo);
1271}
1272
1273static int
1274brcmf_usb_probe(struct usb_interface *intf, const struct usb_device_id *id)
1275{
1276 struct usb_device *usb = interface_to_usbdev(intf);
1277 struct brcmf_usbdev_info *devinfo;
1278 struct usb_interface_descriptor *desc;
1279 struct usb_endpoint_descriptor *endpoint;
1280 int ret = 0;
1281 u32 num_of_eps;
1282 u8 endpoint_num, ep;
1283
1284 brcmf_dbg(USB, "Enter 0x%04x:0x%04x\n", id->idVendor, id->idProduct);
1285
1286 devinfo = kzalloc(sizeof(*devinfo), GFP_ATOMIC);
1287 if (devinfo == NULL)
1288 return -ENOMEM;
1289
1290 devinfo->usbdev = usb;
1291 devinfo->dev = &usb->dev;
1292
1293
1294
1295 mutex_init(&devinfo->dev_init_lock);
1296 mutex_lock(&devinfo->dev_init_lock);
1297
1298 usb_set_intfdata(intf, devinfo);
1299
1300
1301 if (usb->descriptor.bNumConfigurations != 1) {
1302 brcmf_err("Number of configurations: %d not supported\n",
1303 usb->descriptor.bNumConfigurations);
1304 ret = -ENODEV;
1305 goto fail;
1306 }
1307
1308 if ((usb->descriptor.bDeviceClass != USB_CLASS_VENDOR_SPEC) &&
1309 (usb->descriptor.bDeviceClass != USB_CLASS_MISC) &&
1310 (usb->descriptor.bDeviceClass != USB_CLASS_WIRELESS_CONTROLLER)) {
1311 brcmf_err("Device class: 0x%x not supported\n",
1312 usb->descriptor.bDeviceClass);
1313 ret = -ENODEV;
1314 goto fail;
1315 }
1316
1317 desc = &intf->altsetting[0].desc;
1318 if ((desc->bInterfaceClass != USB_CLASS_VENDOR_SPEC) ||
1319 (desc->bInterfaceSubClass != 2) ||
1320 (desc->bInterfaceProtocol != 0xff)) {
1321 brcmf_err("non WLAN interface %d: 0x%x:0x%x:0x%x\n",
1322 desc->bInterfaceNumber, desc->bInterfaceClass,
1323 desc->bInterfaceSubClass, desc->bInterfaceProtocol);
1324 ret = -ENODEV;
1325 goto fail;
1326 }
1327
1328 num_of_eps = desc->bNumEndpoints;
1329 for (ep = 0; ep < num_of_eps; ep++) {
1330 endpoint = &intf->altsetting[0].endpoint[ep].desc;
1331 endpoint_num = usb_endpoint_num(endpoint);
1332 if (!usb_endpoint_xfer_bulk(endpoint))
1333 continue;
1334 if (usb_endpoint_dir_in(endpoint)) {
1335 if (!devinfo->rx_pipe)
1336 devinfo->rx_pipe =
1337 usb_rcvbulkpipe(usb, endpoint_num);
1338 } else {
1339 if (!devinfo->tx_pipe)
1340 devinfo->tx_pipe =
1341 usb_sndbulkpipe(usb, endpoint_num);
1342 }
1343 }
1344 if (devinfo->rx_pipe == 0) {
1345 brcmf_err("No RX (in) Bulk EP found\n");
1346 ret = -ENODEV;
1347 goto fail;
1348 }
1349 if (devinfo->tx_pipe == 0) {
1350 brcmf_err("No TX (out) Bulk EP found\n");
1351 ret = -ENODEV;
1352 goto fail;
1353 }
1354
1355 devinfo->ifnum = desc->bInterfaceNumber;
1356
1357 if (usb->speed == USB_SPEED_SUPER)
1358 brcmf_dbg(USB, "Broadcom super speed USB WLAN interface detected\n");
1359 else if (usb->speed == USB_SPEED_HIGH)
1360 brcmf_dbg(USB, "Broadcom high speed USB WLAN interface detected\n");
1361 else
1362 brcmf_dbg(USB, "Broadcom full speed USB WLAN interface detected\n");
1363
1364 ret = brcmf_usb_probe_cb(devinfo);
1365 if (ret)
1366 goto fail;
1367
1368
1369 return 0;
1370
1371fail:
1372 mutex_unlock(&devinfo->dev_init_lock);
1373 kfree(devinfo);
1374 usb_set_intfdata(intf, NULL);
1375 return ret;
1376}
1377
1378static void
1379brcmf_usb_disconnect(struct usb_interface *intf)
1380{
1381 struct brcmf_usbdev_info *devinfo;
1382
1383 brcmf_dbg(USB, "Enter\n");
1384 devinfo = (struct brcmf_usbdev_info *)usb_get_intfdata(intf);
1385
1386 if (devinfo) {
1387 mutex_lock(&devinfo->dev_init_lock);
1388
1389
1390
1391 if (!usb_get_intfdata(intf))
1392 goto done;
1393
1394 brcmf_usb_disconnect_cb(devinfo);
1395 kfree(devinfo);
1396 }
1397done:
1398 brcmf_dbg(USB, "Exit\n");
1399}
1400
1401
1402
1403
1404static int brcmf_usb_suspend(struct usb_interface *intf, pm_message_t state)
1405{
1406 struct usb_device *usb = interface_to_usbdev(intf);
1407 struct brcmf_usbdev_info *devinfo = brcmf_usb_get_businfo(&usb->dev);
1408
1409 brcmf_dbg(USB, "Enter\n");
1410 devinfo->bus_pub.state = BRCMFMAC_USB_STATE_SLEEP;
1411 if (devinfo->wowl_enabled)
1412 brcmf_cancel_all_urbs(devinfo);
1413 else
1414 brcmf_detach(&usb->dev);
1415 return 0;
1416}
1417
1418
1419
1420
1421static int brcmf_usb_resume(struct usb_interface *intf)
1422{
1423 struct usb_device *usb = interface_to_usbdev(intf);
1424 struct brcmf_usbdev_info *devinfo = brcmf_usb_get_businfo(&usb->dev);
1425
1426 brcmf_dbg(USB, "Enter\n");
1427 if (!devinfo->wowl_enabled)
1428 return brcmf_usb_bus_setup(devinfo);
1429
1430 devinfo->bus_pub.state = BRCMFMAC_USB_STATE_UP;
1431 brcmf_usb_rx_fill_all(devinfo);
1432 return 0;
1433}
1434
1435static int brcmf_usb_reset_resume(struct usb_interface *intf)
1436{
1437 struct usb_device *usb = interface_to_usbdev(intf);
1438 struct brcmf_usbdev_info *devinfo = brcmf_usb_get_businfo(&usb->dev);
1439
1440 brcmf_dbg(USB, "Enter\n");
1441
1442 return brcmf_fw_get_firmwares(&usb->dev, 0, devinfo->fw_name, NULL,
1443 brcmf_usb_probe_phase2);
1444}
1445
1446#define BRCMF_USB_DEVICE(dev_id) \
1447 { USB_DEVICE(BRCM_USB_VENDOR_ID_BROADCOM, dev_id) }
1448
1449static struct usb_device_id brcmf_usb_devid_table[] = {
1450 BRCMF_USB_DEVICE(BRCM_USB_43143_DEVICE_ID),
1451 BRCMF_USB_DEVICE(BRCM_USB_43236_DEVICE_ID),
1452 BRCMF_USB_DEVICE(BRCM_USB_43242_DEVICE_ID),
1453 BRCMF_USB_DEVICE(BRCM_USB_43569_DEVICE_ID),
1454 { USB_DEVICE(BRCM_USB_VENDOR_ID_LG, BRCM_USB_43242_LG_DEVICE_ID) },
1455
1456 BRCMF_USB_DEVICE(BRCM_USB_BCMFW_DEVICE_ID),
1457 { }
1458};
1459
1460MODULE_DEVICE_TABLE(usb, brcmf_usb_devid_table);
1461
1462static struct usb_driver brcmf_usbdrvr = {
1463 .name = KBUILD_MODNAME,
1464 .probe = brcmf_usb_probe,
1465 .disconnect = brcmf_usb_disconnect,
1466 .id_table = brcmf_usb_devid_table,
1467 .suspend = brcmf_usb_suspend,
1468 .resume = brcmf_usb_resume,
1469 .reset_resume = brcmf_usb_reset_resume,
1470 .disable_hub_initiated_lpm = 1,
1471};
1472
1473static int brcmf_usb_reset_device(struct device *dev, void *notused)
1474{
1475
1476
1477
1478 brcmf_dev_reset(dev->parent);
1479 return 0;
1480}
1481
1482void brcmf_usb_exit(void)
1483{
1484 struct device_driver *drv = &brcmf_usbdrvr.drvwrap.driver;
1485 int ret;
1486
1487 brcmf_dbg(USB, "Enter\n");
1488 ret = driver_for_each_device(drv, NULL, NULL,
1489 brcmf_usb_reset_device);
1490 usb_deregister(&brcmf_usbdrvr);
1491}
1492
1493void brcmf_usb_register(void)
1494{
1495 brcmf_dbg(USB, "Enter\n");
1496 usb_register(&brcmf_usbdrvr);
1497}
1498