Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2011 Broadcom Corporation |
| 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 ANY |
| 11 | * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
| 12 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION |
| 13 | * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN |
| 14 | * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
| 15 | */ |
| 16 | |
| 17 | #include <linux/init.h> |
| 18 | #include <linux/kernel.h> |
| 19 | #include <linux/module.h> |
| 20 | #include <linux/kthread.h> |
| 21 | #include <linux/slab.h> |
| 22 | #include <linux/skbuff.h> |
| 23 | #include <linux/netdevice.h> |
| 24 | #include <linux/spinlock.h> |
| 25 | #include <linux/ethtool.h> |
| 26 | #include <linux/fcntl.h> |
| 27 | #include <linux/fs.h> |
| 28 | #include <linux/uaccess.h> |
| 29 | #include <linux/firmware.h> |
| 30 | #include <linux/usb.h> |
Hauke Mehrtens | edb9bc9 | 2012-05-18 20:22:53 +0200 | [diff] [blame] | 31 | #include <linux/vmalloc.h> |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 32 | #include <net/cfg80211.h> |
| 33 | |
| 34 | #include <defs.h> |
| 35 | #include <brcmu_utils.h> |
| 36 | #include <brcmu_wifi.h> |
| 37 | #include <dhd_bus.h> |
| 38 | #include <dhd_dbg.h> |
| 39 | |
| 40 | #include "usb_rdl.h" |
| 41 | #include "usb.h" |
| 42 | |
| 43 | #define IOCTL_RESP_TIMEOUT 2000 |
| 44 | |
| 45 | #define BRCMF_USB_SYNC_TIMEOUT 300 /* ms */ |
| 46 | #define BRCMF_USB_DLIMAGE_SPINWAIT 100 /* in unit of ms */ |
| 47 | #define BRCMF_USB_DLIMAGE_LIMIT 500 /* spinwait limit (ms) */ |
| 48 | |
| 49 | #define BRCMF_POSTBOOT_ID 0xA123 /* ID to detect if dongle |
| 50 | has boot up */ |
| 51 | #define BRCMF_USB_RESETCFG_SPINWAIT 1 /* wait after resetcfg (ms) */ |
| 52 | |
| 53 | #define BRCMF_USB_NRXQ 50 |
| 54 | #define BRCMF_USB_NTXQ 50 |
| 55 | |
| 56 | #define CONFIGDESC(usb) (&((usb)->actconfig)->desc) |
| 57 | #define IFPTR(usb, idx) ((usb)->actconfig->interface[(idx)]) |
| 58 | #define IFALTS(usb, idx) (IFPTR((usb), (idx))->altsetting[0]) |
| 59 | #define IFDESC(usb, idx) IFALTS((usb), (idx)).desc |
| 60 | #define IFEPDESC(usb, idx, ep) (IFALTS((usb), (idx)).endpoint[(ep)]).desc |
| 61 | |
| 62 | #define CONTROL_IF 0 |
| 63 | #define BULK_IF 0 |
| 64 | |
| 65 | #define BRCMF_USB_CBCTL_WRITE 0 |
| 66 | #define BRCMF_USB_CBCTL_READ 1 |
| 67 | #define BRCMF_USB_MAX_PKT_SIZE 1600 |
| 68 | |
Hante Meuleman | 70f0822 | 2012-08-30 19:43:01 +0200 | [diff] [blame] | 69 | #define BRCMF_USB_43143_FW_NAME "brcm/brcmfmac43143.bin" |
Rafał Miłecki | fda8241 | 2012-02-24 07:22:51 +0100 | [diff] [blame] | 70 | #define BRCMF_USB_43236_FW_NAME "brcm/brcmfmac43236b.bin" |
Hante Meuleman | 1212d37 | 2012-08-30 19:43:00 +0200 | [diff] [blame] | 71 | #define BRCMF_USB_43242_FW_NAME "brcm/brcmfmac43242a.bin" |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 72 | |
| 73 | enum usbdev_suspend_state { |
| 74 | USBOS_SUSPEND_STATE_DEVICE_ACTIVE = 0, /* Device is busy, won't allow |
| 75 | suspend */ |
| 76 | USBOS_SUSPEND_STATE_SUSPEND_PENDING, /* Device is idle, can be |
| 77 | * suspended. Wating PM to |
| 78 | * suspend the device |
| 79 | */ |
| 80 | USBOS_SUSPEND_STATE_SUSPENDED /* Device suspended */ |
| 81 | }; |
| 82 | |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 83 | struct brcmf_usb_image { |
Hante Meuleman | 803599d | 2012-09-19 22:21:10 +0200 | [diff] [blame] | 84 | struct list_head list; |
| 85 | s8 *fwname; |
| 86 | u8 *image; |
| 87 | int image_len; |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 88 | }; |
Hante Meuleman | 803599d | 2012-09-19 22:21:10 +0200 | [diff] [blame] | 89 | static struct list_head fw_image_list; |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 90 | |
| 91 | struct intr_transfer_buf { |
| 92 | u32 notification; |
| 93 | u32 reserved; |
| 94 | }; |
| 95 | |
| 96 | struct brcmf_usbdev_info { |
| 97 | struct brcmf_usbdev bus_pub; /* MUST BE FIRST */ |
| 98 | spinlock_t qlock; |
| 99 | struct list_head rx_freeq; |
| 100 | struct list_head rx_postq; |
| 101 | struct list_head tx_freeq; |
| 102 | struct list_head tx_postq; |
| 103 | enum usbdev_suspend_state suspend_state; |
| 104 | uint rx_pipe, tx_pipe, intr_pipe, rx_pipe2; |
| 105 | |
| 106 | bool activity; |
| 107 | int rx_low_watermark; |
| 108 | int tx_low_watermark; |
| 109 | int tx_high_watermark; |
Hante Meuleman | c6ab429 | 2012-09-11 21:18:48 +0200 | [diff] [blame] | 110 | int tx_freecount; |
| 111 | bool tx_flowblock; |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 112 | |
| 113 | struct brcmf_usbreq *tx_reqs; |
| 114 | struct brcmf_usbreq *rx_reqs; |
| 115 | |
| 116 | u8 *image; /* buffer for combine fw and nvram */ |
| 117 | int image_len; |
| 118 | |
| 119 | wait_queue_head_t wait; |
| 120 | bool waitdone; |
| 121 | int sync_urb_status; |
| 122 | |
| 123 | struct usb_device *usbdev; |
| 124 | struct device *dev; |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 125 | |
| 126 | int ctl_in_pipe, ctl_out_pipe; |
| 127 | struct urb *ctl_urb; /* URB for control endpoint */ |
| 128 | struct usb_ctrlrequest ctl_write; |
| 129 | struct usb_ctrlrequest ctl_read; |
| 130 | u32 ctl_urb_actual_length; |
| 131 | int ctl_urb_status; |
| 132 | int ctl_completed; |
| 133 | wait_queue_head_t ioctl_resp_wait; |
| 134 | wait_queue_head_t ctrl_wait; |
| 135 | ulong ctl_op; |
| 136 | |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 137 | struct urb *bulk_urb; /* used for FW download */ |
| 138 | struct urb *intr_urb; /* URB for interrupt endpoint */ |
| 139 | int intr_size; /* Size of interrupt message */ |
| 140 | int interval; /* Interrupt polling interval */ |
| 141 | struct intr_transfer_buf intr; /* Data buffer for interrupt endpoint */ |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 142 | }; |
| 143 | |
| 144 | static void brcmf_usb_rx_refill(struct brcmf_usbdev_info *devinfo, |
| 145 | struct brcmf_usbreq *req); |
| 146 | |
| 147 | MODULE_AUTHOR("Broadcom Corporation"); |
| 148 | MODULE_DESCRIPTION("Broadcom 802.11n wireless LAN fullmac usb driver."); |
| 149 | MODULE_SUPPORTED_DEVICE("Broadcom 802.11n WLAN fullmac usb cards"); |
| 150 | MODULE_LICENSE("Dual BSD/GPL"); |
| 151 | |
| 152 | static struct brcmf_usbdev *brcmf_usb_get_buspub(struct device *dev) |
| 153 | { |
| 154 | struct brcmf_bus *bus_if = dev_get_drvdata(dev); |
| 155 | return bus_if->bus_priv.usb; |
| 156 | } |
| 157 | |
| 158 | static struct brcmf_usbdev_info *brcmf_usb_get_businfo(struct device *dev) |
| 159 | { |
| 160 | return brcmf_usb_get_buspub(dev)->devinfo; |
| 161 | } |
| 162 | |
Hante Meuleman | 70398a5 | 2012-09-27 14:17:47 +0200 | [diff] [blame] | 163 | static int brcmf_usb_ioctl_resp_wait(struct brcmf_usbdev_info *devinfo) |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 164 | { |
Hante Meuleman | 70398a5 | 2012-09-27 14:17:47 +0200 | [diff] [blame] | 165 | return wait_event_timeout(devinfo->ioctl_resp_wait, |
| 166 | devinfo->ctl_completed, |
| 167 | msecs_to_jiffies(IOCTL_RESP_TIMEOUT)); |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 168 | } |
| 169 | |
Hante Meuleman | 70398a5 | 2012-09-27 14:17:47 +0200 | [diff] [blame] | 170 | static void brcmf_usb_ioctl_resp_wake(struct brcmf_usbdev_info *devinfo) |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 171 | { |
| 172 | if (waitqueue_active(&devinfo->ioctl_resp_wait)) |
Hante Meuleman | 70398a5 | 2012-09-27 14:17:47 +0200 | [diff] [blame] | 173 | wake_up(&devinfo->ioctl_resp_wait); |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 174 | } |
| 175 | |
| 176 | static void |
| 177 | brcmf_usb_ctl_complete(struct brcmf_usbdev_info *devinfo, int type, int status) |
| 178 | { |
| 179 | |
| 180 | if (unlikely(devinfo == NULL)) |
| 181 | return; |
| 182 | |
| 183 | if (type == BRCMF_USB_CBCTL_READ) { |
| 184 | if (status == 0) |
| 185 | devinfo->bus_pub.stats.rx_ctlpkts++; |
| 186 | else |
| 187 | devinfo->bus_pub.stats.rx_ctlerrs++; |
| 188 | } else if (type == BRCMF_USB_CBCTL_WRITE) { |
| 189 | if (status == 0) |
| 190 | devinfo->bus_pub.stats.tx_ctlpkts++; |
| 191 | else |
| 192 | devinfo->bus_pub.stats.tx_ctlerrs++; |
| 193 | } |
| 194 | |
| 195 | devinfo->ctl_urb_status = status; |
| 196 | devinfo->ctl_completed = true; |
| 197 | brcmf_usb_ioctl_resp_wake(devinfo); |
| 198 | } |
| 199 | |
| 200 | static void |
| 201 | brcmf_usb_ctlread_complete(struct urb *urb) |
| 202 | { |
| 203 | struct brcmf_usbdev_info *devinfo = |
| 204 | (struct brcmf_usbdev_info *)urb->context; |
| 205 | |
| 206 | devinfo->ctl_urb_actual_length = urb->actual_length; |
| 207 | brcmf_usb_ctl_complete(devinfo, BRCMF_USB_CBCTL_READ, |
| 208 | urb->status); |
| 209 | } |
| 210 | |
| 211 | static void |
| 212 | brcmf_usb_ctlwrite_complete(struct urb *urb) |
| 213 | { |
| 214 | struct brcmf_usbdev_info *devinfo = |
| 215 | (struct brcmf_usbdev_info *)urb->context; |
| 216 | |
| 217 | brcmf_usb_ctl_complete(devinfo, BRCMF_USB_CBCTL_WRITE, |
| 218 | urb->status); |
| 219 | } |
| 220 | |
| 221 | static int brcmf_usb_pnp(struct brcmf_usbdev_info *devinfo, uint state) |
| 222 | { |
| 223 | return 0; |
| 224 | } |
| 225 | |
| 226 | static int |
| 227 | brcmf_usb_send_ctl(struct brcmf_usbdev_info *devinfo, u8 *buf, int len) |
| 228 | { |
| 229 | int ret; |
| 230 | u16 size; |
| 231 | |
| 232 | if (devinfo == NULL || buf == NULL || |
| 233 | len == 0 || devinfo->ctl_urb == NULL) |
| 234 | return -EINVAL; |
| 235 | |
| 236 | /* If the USB/HSIC bus in sleep state, wake it up */ |
| 237 | if (devinfo->suspend_state == USBOS_SUSPEND_STATE_SUSPENDED) |
| 238 | if (brcmf_usb_pnp(devinfo, BCMFMAC_USB_PNP_RESUME) != 0) { |
| 239 | brcmf_dbg(ERROR, "Could not Resume the bus!\n"); |
| 240 | return -EIO; |
| 241 | } |
| 242 | |
| 243 | devinfo->activity = true; |
| 244 | size = len; |
| 245 | devinfo->ctl_write.wLength = cpu_to_le16p(&size); |
| 246 | devinfo->ctl_urb->transfer_buffer_length = size; |
| 247 | devinfo->ctl_urb_status = 0; |
| 248 | devinfo->ctl_urb_actual_length = 0; |
| 249 | |
| 250 | usb_fill_control_urb(devinfo->ctl_urb, |
| 251 | devinfo->usbdev, |
| 252 | devinfo->ctl_out_pipe, |
| 253 | (unsigned char *) &devinfo->ctl_write, |
| 254 | buf, size, |
| 255 | (usb_complete_t)brcmf_usb_ctlwrite_complete, |
| 256 | devinfo); |
| 257 | |
| 258 | ret = usb_submit_urb(devinfo->ctl_urb, GFP_ATOMIC); |
| 259 | if (ret < 0) |
| 260 | brcmf_dbg(ERROR, "usb_submit_urb failed %d\n", ret); |
| 261 | |
| 262 | return ret; |
| 263 | } |
| 264 | |
| 265 | static int |
| 266 | brcmf_usb_recv_ctl(struct brcmf_usbdev_info *devinfo, u8 *buf, int len) |
| 267 | { |
| 268 | int ret; |
| 269 | u16 size; |
| 270 | |
| 271 | if ((devinfo == NULL) || (buf == NULL) || (len == 0) |
| 272 | || (devinfo->ctl_urb == NULL)) |
| 273 | return -EINVAL; |
| 274 | |
| 275 | size = len; |
| 276 | devinfo->ctl_read.wLength = cpu_to_le16p(&size); |
| 277 | devinfo->ctl_urb->transfer_buffer_length = size; |
| 278 | |
Hante Meuleman | 8164329 | 2012-09-19 22:21:14 +0200 | [diff] [blame] | 279 | devinfo->ctl_read.bRequestType = USB_DIR_IN |
| 280 | | USB_TYPE_CLASS | USB_RECIP_INTERFACE; |
| 281 | devinfo->ctl_read.bRequest = 1; |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 282 | |
| 283 | usb_fill_control_urb(devinfo->ctl_urb, |
| 284 | devinfo->usbdev, |
| 285 | devinfo->ctl_in_pipe, |
| 286 | (unsigned char *) &devinfo->ctl_read, |
| 287 | buf, size, |
| 288 | (usb_complete_t)brcmf_usb_ctlread_complete, |
| 289 | devinfo); |
| 290 | |
| 291 | ret = usb_submit_urb(devinfo->ctl_urb, GFP_ATOMIC); |
| 292 | if (ret < 0) |
| 293 | brcmf_dbg(ERROR, "usb_submit_urb failed %d\n", ret); |
| 294 | |
| 295 | return ret; |
| 296 | } |
| 297 | |
| 298 | static int brcmf_usb_tx_ctlpkt(struct device *dev, u8 *buf, u32 len) |
| 299 | { |
| 300 | int err = 0; |
| 301 | int timeout = 0; |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 302 | struct brcmf_usbdev_info *devinfo = brcmf_usb_get_businfo(dev); |
| 303 | |
| 304 | if (devinfo->bus_pub.state != BCMFMAC_USB_STATE_UP) { |
| 305 | /* TODO: handle suspend/resume */ |
| 306 | return -EIO; |
| 307 | } |
| 308 | |
| 309 | if (test_and_set_bit(0, &devinfo->ctl_op)) |
| 310 | return -EIO; |
| 311 | |
Hante Meuleman | a77f574 | 2012-08-30 19:42:58 +0200 | [diff] [blame] | 312 | devinfo->ctl_completed = false; |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 313 | err = brcmf_usb_send_ctl(devinfo, buf, len); |
| 314 | if (err) { |
| 315 | brcmf_dbg(ERROR, "fail %d bytes: %d\n", err, len); |
Hante Meuleman | 6385df2 | 2012-09-19 22:21:16 +0200 | [diff] [blame] | 316 | clear_bit(0, &devinfo->ctl_op); |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 317 | return err; |
| 318 | } |
Hante Meuleman | 70398a5 | 2012-09-27 14:17:47 +0200 | [diff] [blame] | 319 | timeout = brcmf_usb_ioctl_resp_wait(devinfo); |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 320 | clear_bit(0, &devinfo->ctl_op); |
| 321 | if (!timeout) { |
| 322 | brcmf_dbg(ERROR, "Txctl wait timed out\n"); |
| 323 | err = -EIO; |
| 324 | } |
| 325 | return err; |
| 326 | } |
| 327 | |
| 328 | static int brcmf_usb_rx_ctlpkt(struct device *dev, u8 *buf, u32 len) |
| 329 | { |
| 330 | int err = 0; |
| 331 | int timeout = 0; |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 332 | struct brcmf_usbdev_info *devinfo = brcmf_usb_get_businfo(dev); |
| 333 | |
| 334 | if (devinfo->bus_pub.state != BCMFMAC_USB_STATE_UP) { |
| 335 | /* TODO: handle suspend/resume */ |
| 336 | return -EIO; |
| 337 | } |
| 338 | if (test_and_set_bit(0, &devinfo->ctl_op)) |
| 339 | return -EIO; |
| 340 | |
Hante Meuleman | 70398a5 | 2012-09-27 14:17:47 +0200 | [diff] [blame] | 341 | devinfo->ctl_completed = false; |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 342 | err = brcmf_usb_recv_ctl(devinfo, buf, len); |
| 343 | if (err) { |
| 344 | brcmf_dbg(ERROR, "fail %d bytes: %d\n", err, len); |
Hante Meuleman | 6385df2 | 2012-09-19 22:21:16 +0200 | [diff] [blame] | 345 | clear_bit(0, &devinfo->ctl_op); |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 346 | return err; |
| 347 | } |
Hante Meuleman | 70398a5 | 2012-09-27 14:17:47 +0200 | [diff] [blame] | 348 | timeout = brcmf_usb_ioctl_resp_wait(devinfo); |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 349 | err = devinfo->ctl_urb_status; |
| 350 | clear_bit(0, &devinfo->ctl_op); |
| 351 | if (!timeout) { |
| 352 | brcmf_dbg(ERROR, "rxctl wait timed out\n"); |
| 353 | err = -EIO; |
| 354 | } |
| 355 | if (!err) |
| 356 | return devinfo->ctl_urb_actual_length; |
| 357 | else |
| 358 | return err; |
| 359 | } |
| 360 | |
| 361 | static struct brcmf_usbreq *brcmf_usb_deq(struct brcmf_usbdev_info *devinfo, |
Hante Meuleman | c6ab429 | 2012-09-11 21:18:48 +0200 | [diff] [blame] | 362 | struct list_head *q, int *counter) |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 363 | { |
| 364 | unsigned long flags; |
| 365 | struct brcmf_usbreq *req; |
| 366 | spin_lock_irqsave(&devinfo->qlock, flags); |
| 367 | if (list_empty(q)) { |
| 368 | spin_unlock_irqrestore(&devinfo->qlock, flags); |
| 369 | return NULL; |
| 370 | } |
| 371 | req = list_entry(q->next, struct brcmf_usbreq, list); |
| 372 | list_del_init(q->next); |
Hante Meuleman | c6ab429 | 2012-09-11 21:18:48 +0200 | [diff] [blame] | 373 | if (counter) |
| 374 | (*counter)--; |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 375 | spin_unlock_irqrestore(&devinfo->qlock, flags); |
| 376 | return req; |
| 377 | |
| 378 | } |
| 379 | |
| 380 | static void brcmf_usb_enq(struct brcmf_usbdev_info *devinfo, |
Hante Meuleman | c6ab429 | 2012-09-11 21:18:48 +0200 | [diff] [blame] | 381 | struct list_head *q, struct brcmf_usbreq *req, |
| 382 | int *counter) |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 383 | { |
| 384 | unsigned long flags; |
| 385 | spin_lock_irqsave(&devinfo->qlock, flags); |
| 386 | list_add_tail(&req->list, q); |
Hante Meuleman | c6ab429 | 2012-09-11 21:18:48 +0200 | [diff] [blame] | 387 | if (counter) |
| 388 | (*counter)++; |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 389 | spin_unlock_irqrestore(&devinfo->qlock, flags); |
| 390 | } |
| 391 | |
| 392 | static struct brcmf_usbreq * |
| 393 | brcmf_usbdev_qinit(struct list_head *q, int qsize) |
| 394 | { |
| 395 | int i; |
| 396 | struct brcmf_usbreq *req, *reqs; |
| 397 | |
| 398 | reqs = kzalloc(sizeof(struct brcmf_usbreq) * qsize, GFP_ATOMIC); |
| 399 | if (reqs == NULL) { |
| 400 | brcmf_dbg(ERROR, "fail to allocate memory!\n"); |
| 401 | return NULL; |
| 402 | } |
| 403 | req = reqs; |
| 404 | |
| 405 | for (i = 0; i < qsize; i++) { |
| 406 | req->urb = usb_alloc_urb(0, GFP_ATOMIC); |
| 407 | if (!req->urb) |
| 408 | goto fail; |
| 409 | |
| 410 | INIT_LIST_HEAD(&req->list); |
| 411 | list_add_tail(&req->list, q); |
| 412 | req++; |
| 413 | } |
| 414 | return reqs; |
| 415 | fail: |
| 416 | brcmf_dbg(ERROR, "fail!\n"); |
| 417 | while (!list_empty(q)) { |
| 418 | req = list_entry(q->next, struct brcmf_usbreq, list); |
| 419 | if (req && req->urb) |
| 420 | usb_free_urb(req->urb); |
| 421 | list_del(q->next); |
| 422 | } |
| 423 | return NULL; |
| 424 | |
| 425 | } |
| 426 | |
| 427 | static void brcmf_usb_free_q(struct list_head *q, bool pending) |
| 428 | { |
| 429 | struct brcmf_usbreq *req, *next; |
| 430 | int i = 0; |
| 431 | list_for_each_entry_safe(req, next, q, list) { |
Dan Carpenter | d4ca009 | 2012-02-24 09:22:27 +0300 | [diff] [blame] | 432 | if (!req->urb) { |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 433 | brcmf_dbg(ERROR, "bad req\n"); |
| 434 | break; |
| 435 | } |
| 436 | i++; |
| 437 | if (pending) { |
| 438 | usb_kill_urb(req->urb); |
| 439 | } else { |
| 440 | usb_free_urb(req->urb); |
| 441 | list_del_init(&req->list); |
| 442 | } |
| 443 | } |
| 444 | } |
| 445 | |
| 446 | static void brcmf_usb_del_fromq(struct brcmf_usbdev_info *devinfo, |
| 447 | struct brcmf_usbreq *req) |
| 448 | { |
| 449 | unsigned long flags; |
| 450 | |
| 451 | spin_lock_irqsave(&devinfo->qlock, flags); |
| 452 | list_del_init(&req->list); |
| 453 | spin_unlock_irqrestore(&devinfo->qlock, flags); |
| 454 | } |
| 455 | |
| 456 | |
| 457 | static void brcmf_usb_tx_complete(struct urb *urb) |
| 458 | { |
| 459 | struct brcmf_usbreq *req = (struct brcmf_usbreq *)urb->context; |
| 460 | struct brcmf_usbdev_info *devinfo = req->devinfo; |
| 461 | |
| 462 | brcmf_usb_del_fromq(devinfo, req); |
| 463 | if (urb->status == 0) |
Arend van Spriel | 1d9c179 | 2012-03-02 22:55:47 +0100 | [diff] [blame] | 464 | devinfo->bus_pub.bus->dstats.tx_packets++; |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 465 | else |
Arend van Spriel | 1d9c179 | 2012-03-02 22:55:47 +0100 | [diff] [blame] | 466 | devinfo->bus_pub.bus->dstats.tx_errors++; |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 467 | |
Arend van Spriel | 01e3331 | 2012-08-30 10:05:34 +0200 | [diff] [blame] | 468 | brcmu_pkt_buf_free_skb(req->skb); |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 469 | req->skb = NULL; |
Hante Meuleman | c6ab429 | 2012-09-11 21:18:48 +0200 | [diff] [blame] | 470 | brcmf_usb_enq(devinfo, &devinfo->tx_freeq, req, &devinfo->tx_freecount); |
| 471 | if (devinfo->tx_freecount > devinfo->tx_high_watermark && |
| 472 | devinfo->tx_flowblock) { |
| 473 | brcmf_txflowblock(devinfo->dev, false); |
| 474 | devinfo->tx_flowblock = false; |
| 475 | } |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 476 | } |
| 477 | |
| 478 | static void brcmf_usb_rx_complete(struct urb *urb) |
| 479 | { |
| 480 | struct brcmf_usbreq *req = (struct brcmf_usbreq *)urb->context; |
| 481 | struct brcmf_usbdev_info *devinfo = req->devinfo; |
| 482 | struct sk_buff *skb; |
| 483 | int ifidx = 0; |
| 484 | |
| 485 | brcmf_usb_del_fromq(devinfo, req); |
| 486 | skb = req->skb; |
| 487 | req->skb = NULL; |
| 488 | |
| 489 | if (urb->status == 0) { |
Arend van Spriel | 1d9c179 | 2012-03-02 22:55:47 +0100 | [diff] [blame] | 490 | devinfo->bus_pub.bus->dstats.rx_packets++; |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 491 | } else { |
Arend van Spriel | 1d9c179 | 2012-03-02 22:55:47 +0100 | [diff] [blame] | 492 | devinfo->bus_pub.bus->dstats.rx_errors++; |
Arend van Spriel | 01e3331 | 2012-08-30 10:05:34 +0200 | [diff] [blame] | 493 | brcmu_pkt_buf_free_skb(skb); |
Hante Meuleman | c6ab429 | 2012-09-11 21:18:48 +0200 | [diff] [blame] | 494 | brcmf_usb_enq(devinfo, &devinfo->rx_freeq, req, NULL); |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 495 | return; |
| 496 | } |
| 497 | |
| 498 | if (devinfo->bus_pub.state == BCMFMAC_USB_STATE_UP) { |
| 499 | skb_put(skb, urb->actual_length); |
| 500 | if (brcmf_proto_hdrpull(devinfo->dev, &ifidx, skb) != 0) { |
| 501 | brcmf_dbg(ERROR, "rx protocol error\n"); |
| 502 | brcmu_pkt_buf_free_skb(skb); |
| 503 | devinfo->bus_pub.bus->dstats.rx_errors++; |
Hante Meuleman | 64477eb | 2012-09-11 21:18:50 +0200 | [diff] [blame] | 504 | } else |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 505 | brcmf_rx_packet(devinfo->dev, ifidx, skb); |
Hante Meuleman | 64477eb | 2012-09-11 21:18:50 +0200 | [diff] [blame] | 506 | brcmf_usb_rx_refill(devinfo, req); |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 507 | } else { |
Arend van Spriel | 01e3331 | 2012-08-30 10:05:34 +0200 | [diff] [blame] | 508 | brcmu_pkt_buf_free_skb(skb); |
Hante Meuleman | c6ab429 | 2012-09-11 21:18:48 +0200 | [diff] [blame] | 509 | brcmf_usb_enq(devinfo, &devinfo->rx_freeq, req, NULL); |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 510 | } |
| 511 | return; |
| 512 | |
| 513 | } |
| 514 | |
| 515 | static void brcmf_usb_rx_refill(struct brcmf_usbdev_info *devinfo, |
| 516 | struct brcmf_usbreq *req) |
| 517 | { |
| 518 | struct sk_buff *skb; |
| 519 | int ret; |
| 520 | |
| 521 | if (!req || !devinfo) |
| 522 | return; |
| 523 | |
| 524 | skb = dev_alloc_skb(devinfo->bus_pub.bus_mtu); |
| 525 | if (!skb) { |
Hante Meuleman | c6ab429 | 2012-09-11 21:18:48 +0200 | [diff] [blame] | 526 | brcmf_usb_enq(devinfo, &devinfo->rx_freeq, req, NULL); |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 527 | return; |
| 528 | } |
| 529 | req->skb = skb; |
| 530 | |
| 531 | usb_fill_bulk_urb(req->urb, devinfo->usbdev, devinfo->rx_pipe, |
| 532 | skb->data, skb_tailroom(skb), brcmf_usb_rx_complete, |
| 533 | req); |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 534 | req->devinfo = devinfo; |
Hante Meuleman | c6ab429 | 2012-09-11 21:18:48 +0200 | [diff] [blame] | 535 | brcmf_usb_enq(devinfo, &devinfo->rx_postq, req, NULL); |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 536 | |
| 537 | ret = usb_submit_urb(req->urb, GFP_ATOMIC); |
Hante Meuleman | 2e875ac | 2012-08-30 10:05:36 +0200 | [diff] [blame] | 538 | if (ret) { |
| 539 | brcmf_usb_del_fromq(devinfo, req); |
Arend van Spriel | 01e3331 | 2012-08-30 10:05:34 +0200 | [diff] [blame] | 540 | brcmu_pkt_buf_free_skb(req->skb); |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 541 | req->skb = NULL; |
Hante Meuleman | c6ab429 | 2012-09-11 21:18:48 +0200 | [diff] [blame] | 542 | brcmf_usb_enq(devinfo, &devinfo->rx_freeq, req, NULL); |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 543 | } |
| 544 | return; |
| 545 | } |
| 546 | |
| 547 | static void brcmf_usb_rx_fill_all(struct brcmf_usbdev_info *devinfo) |
| 548 | { |
| 549 | struct brcmf_usbreq *req; |
| 550 | |
| 551 | if (devinfo->bus_pub.state != BCMFMAC_USB_STATE_UP) { |
| 552 | brcmf_dbg(ERROR, "bus is not up\n"); |
| 553 | return; |
| 554 | } |
Hante Meuleman | c6ab429 | 2012-09-11 21:18:48 +0200 | [diff] [blame] | 555 | while ((req = brcmf_usb_deq(devinfo, &devinfo->rx_freeq, NULL)) != NULL) |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 556 | brcmf_usb_rx_refill(devinfo, req); |
| 557 | } |
| 558 | |
| 559 | static void |
| 560 | brcmf_usb_state_change(struct brcmf_usbdev_info *devinfo, int state) |
| 561 | { |
| 562 | struct brcmf_bus *bcmf_bus = devinfo->bus_pub.bus; |
| 563 | int old_state; |
| 564 | |
| 565 | |
| 566 | if (devinfo->bus_pub.state == state) |
| 567 | return; |
| 568 | |
| 569 | old_state = devinfo->bus_pub.state; |
| 570 | brcmf_dbg(TRACE, "dbus state change from %d to to %d\n", |
| 571 | old_state, state); |
| 572 | |
| 573 | /* Don't update state if it's PnP firmware re-download */ |
| 574 | if (state != BCMFMAC_USB_STATE_PNP_FWDL) /* TODO */ |
| 575 | devinfo->bus_pub.state = state; |
| 576 | |
| 577 | if ((old_state == BCMFMAC_USB_STATE_SLEEP) |
| 578 | && (state == BCMFMAC_USB_STATE_UP)) { |
| 579 | brcmf_usb_rx_fill_all(devinfo); |
| 580 | } |
| 581 | |
| 582 | /* update state of upper layer */ |
| 583 | if (state == BCMFMAC_USB_STATE_DOWN) { |
| 584 | brcmf_dbg(INFO, "DBUS is down\n"); |
| 585 | bcmf_bus->state = BRCMF_BUS_DOWN; |
| 586 | } else { |
| 587 | brcmf_dbg(INFO, "DBUS current state=%d\n", state); |
| 588 | } |
| 589 | } |
| 590 | |
| 591 | static void |
| 592 | brcmf_usb_intr_complete(struct urb *urb) |
| 593 | { |
| 594 | struct brcmf_usbdev_info *devinfo = |
| 595 | (struct brcmf_usbdev_info *)urb->context; |
| 596 | bool killed; |
| 597 | |
| 598 | if (devinfo == NULL) |
| 599 | return; |
| 600 | |
| 601 | if (unlikely(urb->status)) { |
| 602 | if (devinfo->suspend_state == |
| 603 | USBOS_SUSPEND_STATE_SUSPEND_PENDING) |
| 604 | killed = true; |
| 605 | |
| 606 | if ((urb->status == -ENOENT && (!killed)) |
| 607 | || urb->status == -ESHUTDOWN || |
| 608 | urb->status == -ENODEV) { |
| 609 | brcmf_usb_state_change(devinfo, BCMFMAC_USB_STATE_DOWN); |
| 610 | } |
| 611 | } |
| 612 | |
| 613 | if (devinfo->bus_pub.state == BCMFMAC_USB_STATE_DOWN) { |
| 614 | brcmf_dbg(ERROR, "intr cb when DBUS down, ignoring\n"); |
| 615 | return; |
| 616 | } |
| 617 | |
| 618 | if (devinfo->bus_pub.state == BCMFMAC_USB_STATE_UP) |
| 619 | usb_submit_urb(devinfo->intr_urb, GFP_ATOMIC); |
| 620 | } |
| 621 | |
| 622 | static int brcmf_usb_tx(struct device *dev, struct sk_buff *skb) |
| 623 | { |
| 624 | struct brcmf_usbdev_info *devinfo = brcmf_usb_get_businfo(dev); |
| 625 | struct brcmf_usbreq *req; |
| 626 | int ret; |
| 627 | |
| 628 | if (devinfo->bus_pub.state != BCMFMAC_USB_STATE_UP) { |
| 629 | /* TODO: handle suspend/resume */ |
| 630 | return -EIO; |
| 631 | } |
| 632 | |
Hante Meuleman | c6ab429 | 2012-09-11 21:18:48 +0200 | [diff] [blame] | 633 | req = brcmf_usb_deq(devinfo, &devinfo->tx_freeq, |
| 634 | &devinfo->tx_freecount); |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 635 | if (!req) { |
Hante Meuleman | 2e875ac | 2012-08-30 10:05:36 +0200 | [diff] [blame] | 636 | brcmu_pkt_buf_free_skb(skb); |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 637 | brcmf_dbg(ERROR, "no req to send\n"); |
| 638 | return -ENOMEM; |
| 639 | } |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 640 | |
| 641 | req->skb = skb; |
| 642 | req->devinfo = devinfo; |
| 643 | usb_fill_bulk_urb(req->urb, devinfo->usbdev, devinfo->tx_pipe, |
| 644 | skb->data, skb->len, brcmf_usb_tx_complete, req); |
| 645 | req->urb->transfer_flags |= URB_ZERO_PACKET; |
Hante Meuleman | c6ab429 | 2012-09-11 21:18:48 +0200 | [diff] [blame] | 646 | brcmf_usb_enq(devinfo, &devinfo->tx_postq, req, NULL); |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 647 | ret = usb_submit_urb(req->urb, GFP_ATOMIC); |
Hante Meuleman | 2e875ac | 2012-08-30 10:05:36 +0200 | [diff] [blame] | 648 | if (ret) { |
| 649 | brcmf_dbg(ERROR, "brcmf_usb_tx usb_submit_urb FAILED\n"); |
| 650 | brcmf_usb_del_fromq(devinfo, req); |
| 651 | brcmu_pkt_buf_free_skb(req->skb); |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 652 | req->skb = NULL; |
Hante Meuleman | c6ab429 | 2012-09-11 21:18:48 +0200 | [diff] [blame] | 653 | brcmf_usb_enq(devinfo, &devinfo->tx_freeq, req, |
| 654 | &devinfo->tx_freecount); |
| 655 | } else { |
| 656 | if (devinfo->tx_freecount < devinfo->tx_low_watermark && |
| 657 | !devinfo->tx_flowblock) { |
| 658 | brcmf_txflowblock(dev, true); |
| 659 | devinfo->tx_flowblock = true; |
| 660 | } |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 661 | } |
| 662 | |
| 663 | return ret; |
| 664 | } |
| 665 | |
| 666 | |
| 667 | static int brcmf_usb_up(struct device *dev) |
| 668 | { |
| 669 | struct brcmf_usbdev_info *devinfo = brcmf_usb_get_businfo(dev); |
| 670 | u16 ifnum; |
| 671 | |
Dan Carpenter | d4ca009 | 2012-02-24 09:22:27 +0300 | [diff] [blame] | 672 | if (devinfo->bus_pub.state == BCMFMAC_USB_STATE_UP) |
| 673 | return 0; |
| 674 | |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 675 | /* If the USB/HSIC bus in sleep state, wake it up */ |
| 676 | if (devinfo->suspend_state == USBOS_SUSPEND_STATE_SUSPENDED) { |
| 677 | if (brcmf_usb_pnp(devinfo, BCMFMAC_USB_PNP_RESUME) != 0) { |
| 678 | brcmf_dbg(ERROR, "Could not Resume the bus!\n"); |
| 679 | return -EIO; |
| 680 | } |
| 681 | } |
| 682 | devinfo->activity = true; |
| 683 | |
| 684 | /* Success, indicate devinfo is fully up */ |
| 685 | brcmf_usb_state_change(devinfo, BCMFMAC_USB_STATE_UP); |
| 686 | |
| 687 | if (devinfo->intr_urb) { |
| 688 | int ret; |
| 689 | |
| 690 | usb_fill_int_urb(devinfo->intr_urb, devinfo->usbdev, |
| 691 | devinfo->intr_pipe, |
| 692 | &devinfo->intr, |
| 693 | devinfo->intr_size, |
| 694 | (usb_complete_t)brcmf_usb_intr_complete, |
| 695 | devinfo, |
| 696 | devinfo->interval); |
| 697 | |
| 698 | ret = usb_submit_urb(devinfo->intr_urb, GFP_ATOMIC); |
| 699 | if (ret) { |
| 700 | brcmf_dbg(ERROR, "USB_SUBMIT_URB failed with status %d\n", |
| 701 | ret); |
| 702 | return -EINVAL; |
| 703 | } |
| 704 | } |
| 705 | |
| 706 | if (devinfo->ctl_urb) { |
| 707 | devinfo->ctl_in_pipe = usb_rcvctrlpipe(devinfo->usbdev, 0); |
| 708 | devinfo->ctl_out_pipe = usb_sndctrlpipe(devinfo->usbdev, 0); |
| 709 | |
| 710 | ifnum = IFDESC(devinfo->usbdev, CONTROL_IF).bInterfaceNumber; |
| 711 | |
| 712 | /* CTL Write */ |
| 713 | devinfo->ctl_write.bRequestType = |
| 714 | USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE; |
| 715 | devinfo->ctl_write.bRequest = 0; |
| 716 | devinfo->ctl_write.wValue = cpu_to_le16(0); |
| 717 | devinfo->ctl_write.wIndex = cpu_to_le16p(&ifnum); |
| 718 | |
| 719 | /* CTL Read */ |
| 720 | devinfo->ctl_read.bRequestType = |
| 721 | USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE; |
| 722 | devinfo->ctl_read.bRequest = 1; |
| 723 | devinfo->ctl_read.wValue = cpu_to_le16(0); |
| 724 | devinfo->ctl_read.wIndex = cpu_to_le16p(&ifnum); |
| 725 | } |
| 726 | brcmf_usb_rx_fill_all(devinfo); |
| 727 | return 0; |
| 728 | } |
| 729 | |
| 730 | static void brcmf_usb_down(struct device *dev) |
| 731 | { |
| 732 | struct brcmf_usbdev_info *devinfo = brcmf_usb_get_businfo(dev); |
| 733 | |
| 734 | if (devinfo == NULL) |
| 735 | return; |
| 736 | |
| 737 | brcmf_dbg(TRACE, "enter\n"); |
| 738 | if (devinfo->bus_pub.state == BCMFMAC_USB_STATE_DOWN) |
| 739 | return; |
| 740 | |
| 741 | brcmf_usb_state_change(devinfo, BCMFMAC_USB_STATE_DOWN); |
| 742 | if (devinfo->intr_urb) |
| 743 | usb_kill_urb(devinfo->intr_urb); |
| 744 | |
| 745 | if (devinfo->ctl_urb) |
| 746 | usb_kill_urb(devinfo->ctl_urb); |
| 747 | |
| 748 | if (devinfo->bulk_urb) |
| 749 | usb_kill_urb(devinfo->bulk_urb); |
| 750 | brcmf_usb_free_q(&devinfo->tx_postq, true); |
| 751 | |
| 752 | brcmf_usb_free_q(&devinfo->rx_postq, true); |
| 753 | } |
| 754 | |
| 755 | static int |
| 756 | brcmf_usb_sync_wait(struct brcmf_usbdev_info *devinfo, u16 time) |
| 757 | { |
| 758 | int ret; |
| 759 | int err = 0; |
| 760 | int ms = time; |
| 761 | |
| 762 | ret = wait_event_interruptible_timeout(devinfo->wait, |
| 763 | devinfo->waitdone == true, (ms * HZ / 1000)); |
| 764 | |
| 765 | if ((devinfo->waitdone == false) || (devinfo->sync_urb_status)) { |
| 766 | brcmf_dbg(ERROR, "timeout(%d) or urb err=%d\n", |
| 767 | ret, devinfo->sync_urb_status); |
| 768 | err = -EINVAL; |
| 769 | } |
| 770 | devinfo->waitdone = false; |
| 771 | return err; |
| 772 | } |
| 773 | |
| 774 | static void |
| 775 | brcmf_usb_sync_complete(struct urb *urb) |
| 776 | { |
| 777 | struct brcmf_usbdev_info *devinfo = |
| 778 | (struct brcmf_usbdev_info *)urb->context; |
| 779 | |
| 780 | devinfo->waitdone = true; |
| 781 | wake_up_interruptible(&devinfo->wait); |
| 782 | devinfo->sync_urb_status = urb->status; |
| 783 | } |
| 784 | |
| 785 | static bool brcmf_usb_dl_cmd(struct brcmf_usbdev_info *devinfo, u8 cmd, |
| 786 | void *buffer, int buflen) |
| 787 | { |
| 788 | int ret = 0; |
| 789 | char *tmpbuf; |
| 790 | u16 size; |
| 791 | |
| 792 | if ((!devinfo) || (devinfo->ctl_urb == NULL)) |
| 793 | return false; |
| 794 | |
| 795 | tmpbuf = kmalloc(buflen, GFP_ATOMIC); |
| 796 | if (!tmpbuf) |
| 797 | return false; |
| 798 | |
| 799 | size = buflen; |
| 800 | devinfo->ctl_urb->transfer_buffer_length = size; |
| 801 | |
| 802 | devinfo->ctl_read.wLength = cpu_to_le16p(&size); |
| 803 | devinfo->ctl_read.bRequestType = USB_DIR_IN | USB_TYPE_VENDOR | |
| 804 | USB_RECIP_INTERFACE; |
| 805 | devinfo->ctl_read.bRequest = cmd; |
| 806 | |
| 807 | usb_fill_control_urb(devinfo->ctl_urb, |
| 808 | devinfo->usbdev, |
| 809 | usb_rcvctrlpipe(devinfo->usbdev, 0), |
| 810 | (unsigned char *) &devinfo->ctl_read, |
| 811 | (void *) tmpbuf, size, |
| 812 | (usb_complete_t)brcmf_usb_sync_complete, devinfo); |
| 813 | |
| 814 | ret = usb_submit_urb(devinfo->ctl_urb, GFP_ATOMIC); |
| 815 | if (ret < 0) { |
| 816 | brcmf_dbg(ERROR, "usb_submit_urb failed %d\n", ret); |
| 817 | kfree(tmpbuf); |
| 818 | return false; |
| 819 | } |
| 820 | |
| 821 | ret = brcmf_usb_sync_wait(devinfo, BRCMF_USB_SYNC_TIMEOUT); |
| 822 | memcpy(buffer, tmpbuf, buflen); |
| 823 | kfree(tmpbuf); |
| 824 | |
| 825 | return (ret == 0); |
| 826 | } |
| 827 | |
| 828 | static bool |
| 829 | brcmf_usb_dlneeded(struct brcmf_usbdev_info *devinfo) |
| 830 | { |
| 831 | struct bootrom_id_le id; |
| 832 | u32 chipid, chiprev; |
| 833 | |
| 834 | brcmf_dbg(TRACE, "enter\n"); |
| 835 | |
| 836 | if (devinfo == NULL) |
| 837 | return false; |
| 838 | |
| 839 | /* Check if firmware downloaded already by querying runtime ID */ |
| 840 | id.chip = cpu_to_le32(0xDEAD); |
| 841 | brcmf_usb_dl_cmd(devinfo, DL_GETVER, &id, |
| 842 | sizeof(struct bootrom_id_le)); |
| 843 | |
| 844 | chipid = le32_to_cpu(id.chip); |
| 845 | chiprev = le32_to_cpu(id.chiprev); |
| 846 | |
| 847 | if ((chipid & 0x4300) == 0x4300) |
| 848 | brcmf_dbg(INFO, "chip %x rev 0x%x\n", chipid, chiprev); |
| 849 | else |
| 850 | brcmf_dbg(INFO, "chip %d rev 0x%x\n", chipid, chiprev); |
| 851 | if (chipid == BRCMF_POSTBOOT_ID) { |
| 852 | brcmf_dbg(INFO, "firmware already downloaded\n"); |
| 853 | brcmf_usb_dl_cmd(devinfo, DL_RESETCFG, &id, |
| 854 | sizeof(struct bootrom_id_le)); |
| 855 | return false; |
| 856 | } else { |
Arend van Spriel | ac94f19 | 2012-03-02 22:55:46 +0100 | [diff] [blame] | 857 | devinfo->bus_pub.devid = chipid; |
| 858 | devinfo->bus_pub.chiprev = chiprev; |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 859 | } |
| 860 | return true; |
| 861 | } |
| 862 | |
| 863 | static int |
| 864 | brcmf_usb_resetcfg(struct brcmf_usbdev_info *devinfo) |
| 865 | { |
| 866 | struct bootrom_id_le id; |
| 867 | u16 wait = 0, wait_time; |
| 868 | |
| 869 | brcmf_dbg(TRACE, "enter\n"); |
| 870 | |
| 871 | if (devinfo == NULL) |
| 872 | return -EINVAL; |
| 873 | |
| 874 | /* Give dongle chance to boot */ |
| 875 | wait_time = BRCMF_USB_DLIMAGE_SPINWAIT; |
| 876 | while (wait < BRCMF_USB_DLIMAGE_LIMIT) { |
| 877 | mdelay(wait_time); |
| 878 | wait += wait_time; |
| 879 | id.chip = cpu_to_le32(0xDEAD); /* Get the ID */ |
| 880 | brcmf_usb_dl_cmd(devinfo, DL_GETVER, &id, |
| 881 | sizeof(struct bootrom_id_le)); |
| 882 | if (id.chip == cpu_to_le32(BRCMF_POSTBOOT_ID)) |
| 883 | break; |
| 884 | } |
| 885 | |
| 886 | if (id.chip == cpu_to_le32(BRCMF_POSTBOOT_ID)) { |
| 887 | brcmf_dbg(INFO, "download done %d ms postboot chip 0x%x/rev 0x%x\n", |
| 888 | wait, le32_to_cpu(id.chip), le32_to_cpu(id.chiprev)); |
| 889 | |
| 890 | brcmf_usb_dl_cmd(devinfo, DL_RESETCFG, &id, |
| 891 | sizeof(struct bootrom_id_le)); |
| 892 | |
| 893 | /* XXX this wait may not be necessary */ |
| 894 | mdelay(BRCMF_USB_RESETCFG_SPINWAIT); |
| 895 | return 0; |
| 896 | } else { |
| 897 | brcmf_dbg(ERROR, "Cannot talk to Dongle. Firmware is not UP, %d ms\n", |
| 898 | wait); |
| 899 | return -EINVAL; |
| 900 | } |
| 901 | } |
| 902 | |
| 903 | |
| 904 | static int |
| 905 | brcmf_usb_dl_send_bulk(struct brcmf_usbdev_info *devinfo, void *buffer, int len) |
| 906 | { |
| 907 | int ret; |
| 908 | |
| 909 | if ((devinfo == NULL) || (devinfo->bulk_urb == NULL)) |
| 910 | return -EINVAL; |
| 911 | |
| 912 | /* Prepare the URB */ |
| 913 | usb_fill_bulk_urb(devinfo->bulk_urb, devinfo->usbdev, |
| 914 | devinfo->tx_pipe, buffer, len, |
| 915 | (usb_complete_t)brcmf_usb_sync_complete, devinfo); |
| 916 | |
| 917 | devinfo->bulk_urb->transfer_flags |= URB_ZERO_PACKET; |
| 918 | |
| 919 | ret = usb_submit_urb(devinfo->bulk_urb, GFP_ATOMIC); |
| 920 | if (ret) { |
| 921 | brcmf_dbg(ERROR, "usb_submit_urb failed %d\n", ret); |
| 922 | return ret; |
| 923 | } |
| 924 | ret = brcmf_usb_sync_wait(devinfo, BRCMF_USB_SYNC_TIMEOUT); |
| 925 | return ret; |
| 926 | } |
| 927 | |
| 928 | static int |
| 929 | brcmf_usb_dl_writeimage(struct brcmf_usbdev_info *devinfo, u8 *fw, int fwlen) |
| 930 | { |
| 931 | unsigned int sendlen, sent, dllen; |
| 932 | char *bulkchunk = NULL, *dlpos; |
| 933 | struct rdl_state_le state; |
| 934 | u32 rdlstate, rdlbytes; |
| 935 | int err = 0; |
| 936 | brcmf_dbg(TRACE, "fw %p, len %d\n", fw, fwlen); |
| 937 | |
| 938 | bulkchunk = kmalloc(RDL_CHUNK, GFP_ATOMIC); |
| 939 | if (bulkchunk == NULL) { |
| 940 | err = -ENOMEM; |
| 941 | goto fail; |
| 942 | } |
| 943 | |
| 944 | /* 1) Prepare USB boot loader for runtime image */ |
| 945 | brcmf_usb_dl_cmd(devinfo, DL_START, &state, |
| 946 | sizeof(struct rdl_state_le)); |
| 947 | |
| 948 | rdlstate = le32_to_cpu(state.state); |
| 949 | rdlbytes = le32_to_cpu(state.bytes); |
| 950 | |
| 951 | /* 2) Check we are in the Waiting state */ |
| 952 | if (rdlstate != DL_WAITING) { |
| 953 | brcmf_dbg(ERROR, "Failed to DL_START\n"); |
| 954 | err = -EINVAL; |
| 955 | goto fail; |
| 956 | } |
| 957 | sent = 0; |
| 958 | dlpos = fw; |
| 959 | dllen = fwlen; |
| 960 | |
| 961 | /* Get chip id and rev */ |
| 962 | while (rdlbytes != dllen) { |
| 963 | /* Wait until the usb device reports it received all |
| 964 | * the bytes we sent */ |
| 965 | if ((rdlbytes == sent) && (rdlbytes != dllen)) { |
| 966 | if ((dllen-sent) < RDL_CHUNK) |
| 967 | sendlen = dllen-sent; |
| 968 | else |
| 969 | sendlen = RDL_CHUNK; |
| 970 | |
| 971 | /* simply avoid having to send a ZLP by ensuring we |
| 972 | * never have an even |
| 973 | * multiple of 64 |
| 974 | */ |
| 975 | if (!(sendlen % 64)) |
| 976 | sendlen -= 4; |
| 977 | |
| 978 | /* send data */ |
| 979 | memcpy(bulkchunk, dlpos, sendlen); |
| 980 | if (brcmf_usb_dl_send_bulk(devinfo, bulkchunk, |
| 981 | sendlen)) { |
| 982 | brcmf_dbg(ERROR, "send_bulk failed\n"); |
| 983 | err = -EINVAL; |
| 984 | goto fail; |
| 985 | } |
| 986 | |
| 987 | dlpos += sendlen; |
| 988 | sent += sendlen; |
| 989 | } |
| 990 | if (!brcmf_usb_dl_cmd(devinfo, DL_GETSTATE, &state, |
| 991 | sizeof(struct rdl_state_le))) { |
| 992 | brcmf_dbg(ERROR, "DL_GETSTATE Failed xxxx\n"); |
| 993 | err = -EINVAL; |
| 994 | goto fail; |
| 995 | } |
| 996 | |
| 997 | rdlstate = le32_to_cpu(state.state); |
| 998 | rdlbytes = le32_to_cpu(state.bytes); |
| 999 | |
| 1000 | /* restart if an error is reported */ |
| 1001 | if (rdlstate == DL_BAD_HDR || rdlstate == DL_BAD_CRC) { |
| 1002 | brcmf_dbg(ERROR, "Bad Hdr or Bad CRC state %d\n", |
| 1003 | rdlstate); |
| 1004 | err = -EINVAL; |
| 1005 | goto fail; |
| 1006 | } |
| 1007 | } |
| 1008 | |
| 1009 | fail: |
| 1010 | kfree(bulkchunk); |
| 1011 | brcmf_dbg(TRACE, "err=%d\n", err); |
| 1012 | return err; |
| 1013 | } |
| 1014 | |
| 1015 | static int brcmf_usb_dlstart(struct brcmf_usbdev_info *devinfo, u8 *fw, int len) |
| 1016 | { |
| 1017 | int err; |
| 1018 | |
| 1019 | brcmf_dbg(TRACE, "enter\n"); |
| 1020 | |
| 1021 | if (devinfo == NULL) |
| 1022 | return -EINVAL; |
| 1023 | |
Arend van Spriel | ac94f19 | 2012-03-02 22:55:46 +0100 | [diff] [blame] | 1024 | if (devinfo->bus_pub.devid == 0xDEAD) |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1025 | return -EINVAL; |
| 1026 | |
| 1027 | err = brcmf_usb_dl_writeimage(devinfo, fw, len); |
| 1028 | if (err == 0) |
| 1029 | devinfo->bus_pub.state = BCMFMAC_USB_STATE_DL_DONE; |
| 1030 | else |
| 1031 | devinfo->bus_pub.state = BCMFMAC_USB_STATE_DL_PENDING; |
| 1032 | brcmf_dbg(TRACE, "exit: err=%d\n", err); |
| 1033 | |
| 1034 | return err; |
| 1035 | } |
| 1036 | |
| 1037 | static int brcmf_usb_dlrun(struct brcmf_usbdev_info *devinfo) |
| 1038 | { |
| 1039 | struct rdl_state_le state; |
| 1040 | |
| 1041 | brcmf_dbg(TRACE, "enter\n"); |
| 1042 | if (!devinfo) |
| 1043 | return -EINVAL; |
| 1044 | |
Arend van Spriel | ac94f19 | 2012-03-02 22:55:46 +0100 | [diff] [blame] | 1045 | if (devinfo->bus_pub.devid == 0xDEAD) |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1046 | return -EINVAL; |
| 1047 | |
| 1048 | /* Check we are runnable */ |
| 1049 | brcmf_usb_dl_cmd(devinfo, DL_GETSTATE, &state, |
| 1050 | sizeof(struct rdl_state_le)); |
| 1051 | |
| 1052 | /* Start the image */ |
| 1053 | if (state.state == cpu_to_le32(DL_RUNNABLE)) { |
| 1054 | if (!brcmf_usb_dl_cmd(devinfo, DL_GO, &state, |
| 1055 | sizeof(struct rdl_state_le))) |
| 1056 | return -ENODEV; |
| 1057 | if (brcmf_usb_resetcfg(devinfo)) |
| 1058 | return -ENODEV; |
| 1059 | /* The Dongle may go for re-enumeration. */ |
| 1060 | } else { |
| 1061 | brcmf_dbg(ERROR, "Dongle not runnable\n"); |
| 1062 | return -EINVAL; |
| 1063 | } |
| 1064 | brcmf_dbg(TRACE, "exit\n"); |
| 1065 | return 0; |
| 1066 | } |
| 1067 | |
| 1068 | static bool brcmf_usb_chip_support(int chipid, int chiprev) |
| 1069 | { |
| 1070 | switch(chipid) { |
Hante Meuleman | 70f0822 | 2012-08-30 19:43:01 +0200 | [diff] [blame] | 1071 | case 43143: |
| 1072 | return true; |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1073 | case 43235: |
| 1074 | case 43236: |
| 1075 | case 43238: |
| 1076 | return (chiprev == 3); |
Hante Meuleman | 1212d37 | 2012-08-30 19:43:00 +0200 | [diff] [blame] | 1077 | case 43242: |
| 1078 | return true; |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1079 | default: |
| 1080 | break; |
| 1081 | } |
| 1082 | return false; |
| 1083 | } |
| 1084 | |
| 1085 | static int |
| 1086 | brcmf_usb_fw_download(struct brcmf_usbdev_info *devinfo) |
| 1087 | { |
Arend van Spriel | ac94f19 | 2012-03-02 22:55:46 +0100 | [diff] [blame] | 1088 | int devid, chiprev; |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1089 | int err; |
| 1090 | |
| 1091 | brcmf_dbg(TRACE, "enter\n"); |
| 1092 | if (devinfo == NULL) |
| 1093 | return -ENODEV; |
| 1094 | |
Arend van Spriel | ac94f19 | 2012-03-02 22:55:46 +0100 | [diff] [blame] | 1095 | devid = devinfo->bus_pub.devid; |
| 1096 | chiprev = devinfo->bus_pub.chiprev; |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1097 | |
Arend van Spriel | ac94f19 | 2012-03-02 22:55:46 +0100 | [diff] [blame] | 1098 | if (!brcmf_usb_chip_support(devid, chiprev)) { |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1099 | brcmf_dbg(ERROR, "unsupported chip %d rev %d\n", |
Arend van Spriel | ac94f19 | 2012-03-02 22:55:46 +0100 | [diff] [blame] | 1100 | devid, chiprev); |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1101 | return -EINVAL; |
| 1102 | } |
| 1103 | |
| 1104 | if (!devinfo->image) { |
| 1105 | brcmf_dbg(ERROR, "No firmware!\n"); |
| 1106 | return -ENOENT; |
| 1107 | } |
| 1108 | |
| 1109 | err = brcmf_usb_dlstart(devinfo, |
| 1110 | devinfo->image, devinfo->image_len); |
| 1111 | if (err == 0) |
| 1112 | err = brcmf_usb_dlrun(devinfo); |
| 1113 | return err; |
| 1114 | } |
| 1115 | |
| 1116 | |
Hante Meuleman | d74a0b5 | 2012-09-11 21:18:51 +0200 | [diff] [blame] | 1117 | static void brcmf_usb_detach(struct brcmf_usbdev_info *devinfo) |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1118 | { |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1119 | brcmf_dbg(TRACE, "devinfo %p\n", devinfo); |
| 1120 | |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1121 | /* free the URBS */ |
| 1122 | brcmf_usb_free_q(&devinfo->rx_freeq, false); |
| 1123 | brcmf_usb_free_q(&devinfo->tx_freeq, false); |
| 1124 | |
| 1125 | usb_free_urb(devinfo->intr_urb); |
| 1126 | usb_free_urb(devinfo->ctl_urb); |
| 1127 | usb_free_urb(devinfo->bulk_urb); |
| 1128 | |
| 1129 | kfree(devinfo->tx_reqs); |
| 1130 | kfree(devinfo->rx_reqs); |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1131 | } |
| 1132 | |
| 1133 | #define TRX_MAGIC 0x30524448 /* "HDR0" */ |
| 1134 | #define TRX_VERSION 1 /* Version 1 */ |
| 1135 | #define TRX_MAX_LEN 0x3B0000 /* Max length */ |
| 1136 | #define TRX_NO_HEADER 1 /* Do not write TRX header */ |
| 1137 | #define TRX_MAX_OFFSET 3 /* Max number of individual files */ |
| 1138 | #define TRX_UNCOMP_IMAGE 0x20 /* Trx contains uncompressed image */ |
| 1139 | |
| 1140 | struct trx_header_le { |
| 1141 | __le32 magic; /* "HDR0" */ |
| 1142 | __le32 len; /* Length of file including header */ |
| 1143 | __le32 crc32; /* CRC from flag_version to end of file */ |
| 1144 | __le32 flag_version; /* 0:15 flags, 16:31 version */ |
| 1145 | __le32 offsets[TRX_MAX_OFFSET]; /* Offsets of partitions from start of |
| 1146 | * header */ |
| 1147 | }; |
| 1148 | |
| 1149 | static int check_file(const u8 *headers) |
| 1150 | { |
| 1151 | struct trx_header_le *trx; |
| 1152 | int actual_len = -1; |
| 1153 | |
| 1154 | /* Extract trx header */ |
| 1155 | trx = (struct trx_header_le *) headers; |
| 1156 | if (trx->magic != cpu_to_le32(TRX_MAGIC)) |
| 1157 | return -1; |
| 1158 | |
| 1159 | headers += sizeof(struct trx_header_le); |
| 1160 | |
| 1161 | if (le32_to_cpu(trx->flag_version) & TRX_UNCOMP_IMAGE) { |
| 1162 | actual_len = le32_to_cpu(trx->offsets[TRX_OFFSETS_DLFWLEN_IDX]); |
| 1163 | return actual_len + sizeof(struct trx_header_le); |
| 1164 | } |
| 1165 | return -1; |
| 1166 | } |
| 1167 | |
| 1168 | static int brcmf_usb_get_fw(struct brcmf_usbdev_info *devinfo) |
| 1169 | { |
| 1170 | s8 *fwname; |
| 1171 | const struct firmware *fw; |
Hante Meuleman | 803599d | 2012-09-19 22:21:10 +0200 | [diff] [blame] | 1172 | struct brcmf_usb_image *fw_image; |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1173 | int err; |
| 1174 | |
Hante Meuleman | 1212d37 | 2012-08-30 19:43:00 +0200 | [diff] [blame] | 1175 | switch (devinfo->bus_pub.devid) { |
Hante Meuleman | 70f0822 | 2012-08-30 19:43:01 +0200 | [diff] [blame] | 1176 | case 43143: |
| 1177 | fwname = BRCMF_USB_43143_FW_NAME; |
| 1178 | break; |
Hante Meuleman | 1212d37 | 2012-08-30 19:43:00 +0200 | [diff] [blame] | 1179 | case 43235: |
| 1180 | case 43236: |
| 1181 | case 43238: |
| 1182 | fwname = BRCMF_USB_43236_FW_NAME; |
| 1183 | break; |
| 1184 | case 43242: |
| 1185 | fwname = BRCMF_USB_43242_FW_NAME; |
| 1186 | break; |
| 1187 | default: |
| 1188 | return -EINVAL; |
| 1189 | break; |
| 1190 | } |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1191 | |
Hante Meuleman | 803599d | 2012-09-19 22:21:10 +0200 | [diff] [blame] | 1192 | list_for_each_entry(fw_image, &fw_image_list, list) { |
| 1193 | if (fw_image->fwname == fwname) { |
| 1194 | devinfo->image = fw_image->image; |
| 1195 | devinfo->image_len = fw_image->image_len; |
| 1196 | return 0; |
| 1197 | } |
| 1198 | } |
| 1199 | /* fw image not yet loaded. Load it now and add to list */ |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1200 | err = request_firmware(&fw, fwname, devinfo->dev); |
| 1201 | if (!fw) { |
| 1202 | brcmf_dbg(ERROR, "fail to request firmware %s\n", fwname); |
| 1203 | return err; |
| 1204 | } |
| 1205 | if (check_file(fw->data) < 0) { |
| 1206 | brcmf_dbg(ERROR, "invalid firmware %s\n", fwname); |
| 1207 | return -EINVAL; |
| 1208 | } |
| 1209 | |
Hante Meuleman | 803599d | 2012-09-19 22:21:10 +0200 | [diff] [blame] | 1210 | fw_image = kzalloc(sizeof(*fw_image), GFP_ATOMIC); |
| 1211 | if (!fw_image) |
| 1212 | return -ENOMEM; |
| 1213 | INIT_LIST_HEAD(&fw_image->list); |
| 1214 | list_add_tail(&fw_image->list, &fw_image_list); |
| 1215 | fw_image->fwname = fwname; |
| 1216 | fw_image->image = vmalloc(fw->size); |
| 1217 | if (!fw_image->image) |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1218 | return -ENOMEM; |
| 1219 | |
Hante Meuleman | 803599d | 2012-09-19 22:21:10 +0200 | [diff] [blame] | 1220 | memcpy(fw_image->image, fw->data, fw->size); |
| 1221 | fw_image->image_len = fw->size; |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1222 | |
| 1223 | release_firmware(fw); |
Hante Meuleman | 803599d | 2012-09-19 22:21:10 +0200 | [diff] [blame] | 1224 | |
| 1225 | devinfo->image = fw_image->image; |
| 1226 | devinfo->image_len = fw_image->image_len; |
| 1227 | |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1228 | return 0; |
| 1229 | } |
| 1230 | |
| 1231 | |
| 1232 | static |
Hante Meuleman | d74a0b5 | 2012-09-11 21:18:51 +0200 | [diff] [blame] | 1233 | struct brcmf_usbdev *brcmf_usb_attach(struct brcmf_usbdev_info *devinfo, |
| 1234 | int nrxq, int ntxq) |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1235 | { |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1236 | devinfo->bus_pub.nrxq = nrxq; |
| 1237 | devinfo->rx_low_watermark = nrxq / 2; |
| 1238 | devinfo->bus_pub.devinfo = devinfo; |
| 1239 | devinfo->bus_pub.ntxq = ntxq; |
| 1240 | |
| 1241 | /* flow control when too many tx urbs posted */ |
| 1242 | devinfo->tx_low_watermark = ntxq / 4; |
| 1243 | devinfo->tx_high_watermark = devinfo->tx_low_watermark * 3; |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1244 | devinfo->bus_pub.bus_mtu = BRCMF_USB_MAX_PKT_SIZE; |
| 1245 | |
| 1246 | /* Initialize other structure content */ |
| 1247 | init_waitqueue_head(&devinfo->ioctl_resp_wait); |
| 1248 | |
| 1249 | /* Initialize the spinlocks */ |
| 1250 | spin_lock_init(&devinfo->qlock); |
| 1251 | |
| 1252 | INIT_LIST_HEAD(&devinfo->rx_freeq); |
| 1253 | INIT_LIST_HEAD(&devinfo->rx_postq); |
| 1254 | |
| 1255 | INIT_LIST_HEAD(&devinfo->tx_freeq); |
| 1256 | INIT_LIST_HEAD(&devinfo->tx_postq); |
| 1257 | |
Hante Meuleman | c6ab429 | 2012-09-11 21:18:48 +0200 | [diff] [blame] | 1258 | devinfo->tx_flowblock = false; |
| 1259 | |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1260 | devinfo->rx_reqs = brcmf_usbdev_qinit(&devinfo->rx_freeq, nrxq); |
| 1261 | if (!devinfo->rx_reqs) |
| 1262 | goto error; |
| 1263 | |
| 1264 | devinfo->tx_reqs = brcmf_usbdev_qinit(&devinfo->tx_freeq, ntxq); |
| 1265 | if (!devinfo->tx_reqs) |
| 1266 | goto error; |
Hante Meuleman | c6ab429 | 2012-09-11 21:18:48 +0200 | [diff] [blame] | 1267 | devinfo->tx_freecount = ntxq; |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1268 | |
| 1269 | devinfo->intr_urb = usb_alloc_urb(0, GFP_ATOMIC); |
| 1270 | if (!devinfo->intr_urb) { |
| 1271 | brcmf_dbg(ERROR, "usb_alloc_urb (intr) failed\n"); |
| 1272 | goto error; |
| 1273 | } |
| 1274 | devinfo->ctl_urb = usb_alloc_urb(0, GFP_ATOMIC); |
| 1275 | if (!devinfo->ctl_urb) { |
| 1276 | brcmf_dbg(ERROR, "usb_alloc_urb (ctl) failed\n"); |
| 1277 | goto error; |
| 1278 | } |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1279 | devinfo->bulk_urb = usb_alloc_urb(0, GFP_ATOMIC); |
| 1280 | if (!devinfo->bulk_urb) { |
| 1281 | brcmf_dbg(ERROR, "usb_alloc_urb (bulk) failed\n"); |
| 1282 | goto error; |
| 1283 | } |
| 1284 | |
| 1285 | init_waitqueue_head(&devinfo->wait); |
| 1286 | if (!brcmf_usb_dlneeded(devinfo)) |
| 1287 | return &devinfo->bus_pub; |
| 1288 | |
| 1289 | brcmf_dbg(TRACE, "start fw downloading\n"); |
| 1290 | if (brcmf_usb_get_fw(devinfo)) |
| 1291 | goto error; |
| 1292 | |
| 1293 | if (brcmf_usb_fw_download(devinfo)) |
| 1294 | goto error; |
| 1295 | |
| 1296 | return &devinfo->bus_pub; |
| 1297 | |
| 1298 | error: |
| 1299 | brcmf_dbg(ERROR, "failed!\n"); |
Hante Meuleman | d74a0b5 | 2012-09-11 21:18:51 +0200 | [diff] [blame] | 1300 | brcmf_usb_detach(devinfo); |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1301 | return NULL; |
| 1302 | } |
| 1303 | |
Hante Meuleman | d74a0b5 | 2012-09-11 21:18:51 +0200 | [diff] [blame] | 1304 | static int brcmf_usb_probe_cb(struct brcmf_usbdev_info *devinfo, |
| 1305 | const char *desc, u32 bustype, u32 hdrlen) |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1306 | { |
| 1307 | struct brcmf_bus *bus = NULL; |
| 1308 | struct brcmf_usbdev *bus_pub = NULL; |
| 1309 | int ret; |
Hante Meuleman | d74a0b5 | 2012-09-11 21:18:51 +0200 | [diff] [blame] | 1310 | struct device *dev = devinfo->dev; |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1311 | |
Hante Meuleman | d74a0b5 | 2012-09-11 21:18:51 +0200 | [diff] [blame] | 1312 | bus_pub = brcmf_usb_attach(devinfo, BRCMF_USB_NRXQ, BRCMF_USB_NTXQ); |
Hante Meuleman | 9cd23a7 | 2012-09-13 21:12:04 +0200 | [diff] [blame] | 1313 | if (!bus_pub) |
| 1314 | return -ENODEV; |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1315 | |
| 1316 | bus = kzalloc(sizeof(struct brcmf_bus), GFP_ATOMIC); |
| 1317 | if (!bus) { |
| 1318 | ret = -ENOMEM; |
| 1319 | goto fail; |
| 1320 | } |
| 1321 | |
| 1322 | bus_pub->bus = bus; |
| 1323 | bus->brcmf_bus_txdata = brcmf_usb_tx; |
| 1324 | bus->brcmf_bus_init = brcmf_usb_up; |
| 1325 | bus->brcmf_bus_stop = brcmf_usb_down; |
| 1326 | bus->brcmf_bus_txctl = brcmf_usb_tx_ctlpkt; |
| 1327 | bus->brcmf_bus_rxctl = brcmf_usb_rx_ctlpkt; |
| 1328 | bus->type = bustype; |
| 1329 | bus->bus_priv.usb = bus_pub; |
| 1330 | dev_set_drvdata(dev, bus); |
| 1331 | |
| 1332 | /* Attach to the common driver interface */ |
| 1333 | ret = brcmf_attach(hdrlen, dev); |
| 1334 | if (ret) { |
| 1335 | brcmf_dbg(ERROR, "dhd_attach failed\n"); |
| 1336 | goto fail; |
| 1337 | } |
| 1338 | |
| 1339 | ret = brcmf_bus_start(dev); |
| 1340 | if (ret == -ENOLINK) { |
| 1341 | brcmf_dbg(ERROR, "dongle is not responding\n"); |
| 1342 | brcmf_detach(dev); |
| 1343 | goto fail; |
| 1344 | } |
| 1345 | |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1346 | return 0; |
| 1347 | fail: |
| 1348 | /* Release resources in reverse order */ |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1349 | kfree(bus); |
Hante Meuleman | d74a0b5 | 2012-09-11 21:18:51 +0200 | [diff] [blame] | 1350 | brcmf_usb_detach(devinfo); |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1351 | return ret; |
| 1352 | } |
| 1353 | |
| 1354 | static void |
Hante Meuleman | d74a0b5 | 2012-09-11 21:18:51 +0200 | [diff] [blame] | 1355 | brcmf_usb_disconnect_cb(struct brcmf_usbdev_info *devinfo) |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1356 | { |
Hante Meuleman | d74a0b5 | 2012-09-11 21:18:51 +0200 | [diff] [blame] | 1357 | if (!devinfo) |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1358 | return; |
Hante Meuleman | d74a0b5 | 2012-09-11 21:18:51 +0200 | [diff] [blame] | 1359 | brcmf_dbg(TRACE, "enter: bus_pub %p\n", devinfo); |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1360 | |
Hante Meuleman | d74a0b5 | 2012-09-11 21:18:51 +0200 | [diff] [blame] | 1361 | brcmf_detach(devinfo->dev); |
| 1362 | kfree(devinfo->bus_pub.bus); |
| 1363 | brcmf_usb_detach(devinfo); |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1364 | } |
| 1365 | |
| 1366 | static int |
| 1367 | brcmf_usb_probe(struct usb_interface *intf, const struct usb_device_id *id) |
| 1368 | { |
| 1369 | int ep; |
| 1370 | struct usb_endpoint_descriptor *endpoint; |
| 1371 | int ret = 0; |
| 1372 | struct usb_device *usb = interface_to_usbdev(intf); |
| 1373 | int num_of_eps; |
| 1374 | u8 endpoint_num; |
Hante Meuleman | d74a0b5 | 2012-09-11 21:18:51 +0200 | [diff] [blame] | 1375 | struct brcmf_usbdev_info *devinfo; |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1376 | |
| 1377 | brcmf_dbg(TRACE, "enter\n"); |
| 1378 | |
Hante Meuleman | d74a0b5 | 2012-09-11 21:18:51 +0200 | [diff] [blame] | 1379 | devinfo = kzalloc(sizeof(*devinfo), GFP_ATOMIC); |
| 1380 | if (devinfo == NULL) |
| 1381 | return -ENOMEM; |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1382 | |
Hante Meuleman | d74a0b5 | 2012-09-11 21:18:51 +0200 | [diff] [blame] | 1383 | devinfo->usbdev = usb; |
| 1384 | devinfo->dev = &usb->dev; |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1385 | |
Hante Meuleman | d74a0b5 | 2012-09-11 21:18:51 +0200 | [diff] [blame] | 1386 | usb_set_intfdata(intf, devinfo); |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1387 | |
| 1388 | /* Check that the device supports only one configuration */ |
| 1389 | if (usb->descriptor.bNumConfigurations != 1) { |
| 1390 | ret = -1; |
| 1391 | goto fail; |
| 1392 | } |
| 1393 | |
| 1394 | if (usb->descriptor.bDeviceClass != USB_CLASS_VENDOR_SPEC) { |
| 1395 | ret = -1; |
| 1396 | goto fail; |
| 1397 | } |
| 1398 | |
| 1399 | /* |
| 1400 | * Only the BDC interface configuration is supported: |
| 1401 | * Device class: USB_CLASS_VENDOR_SPEC |
| 1402 | * if0 class: USB_CLASS_VENDOR_SPEC |
| 1403 | * if0/ep0: control |
| 1404 | * if0/ep1: bulk in |
| 1405 | * if0/ep2: bulk out (ok if swapped with bulk in) |
| 1406 | */ |
| 1407 | if (CONFIGDESC(usb)->bNumInterfaces != 1) { |
| 1408 | ret = -1; |
| 1409 | goto fail; |
| 1410 | } |
| 1411 | |
| 1412 | /* Check interface */ |
| 1413 | if (IFDESC(usb, CONTROL_IF).bInterfaceClass != USB_CLASS_VENDOR_SPEC || |
| 1414 | IFDESC(usb, CONTROL_IF).bInterfaceSubClass != 2 || |
| 1415 | IFDESC(usb, CONTROL_IF).bInterfaceProtocol != 0xff) { |
| 1416 | brcmf_dbg(ERROR, "invalid control interface: class %d, subclass %d, proto %d\n", |
| 1417 | IFDESC(usb, CONTROL_IF).bInterfaceClass, |
| 1418 | IFDESC(usb, CONTROL_IF).bInterfaceSubClass, |
| 1419 | IFDESC(usb, CONTROL_IF).bInterfaceProtocol); |
| 1420 | ret = -1; |
| 1421 | goto fail; |
| 1422 | } |
| 1423 | |
| 1424 | /* Check control endpoint */ |
| 1425 | endpoint = &IFEPDESC(usb, CONTROL_IF, 0); |
| 1426 | if ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) |
| 1427 | != USB_ENDPOINT_XFER_INT) { |
| 1428 | brcmf_dbg(ERROR, "invalid control endpoint %d\n", |
| 1429 | endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK); |
| 1430 | ret = -1; |
| 1431 | goto fail; |
| 1432 | } |
| 1433 | |
| 1434 | endpoint_num = endpoint->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK; |
Hante Meuleman | d74a0b5 | 2012-09-11 21:18:51 +0200 | [diff] [blame] | 1435 | devinfo->intr_pipe = usb_rcvintpipe(usb, endpoint_num); |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1436 | |
Hante Meuleman | d74a0b5 | 2012-09-11 21:18:51 +0200 | [diff] [blame] | 1437 | devinfo->rx_pipe = 0; |
| 1438 | devinfo->rx_pipe2 = 0; |
| 1439 | devinfo->tx_pipe = 0; |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1440 | num_of_eps = IFDESC(usb, BULK_IF).bNumEndpoints - 1; |
| 1441 | |
| 1442 | /* Check data endpoints and get pipes */ |
| 1443 | for (ep = 1; ep <= num_of_eps; ep++) { |
| 1444 | endpoint = &IFEPDESC(usb, BULK_IF, ep); |
| 1445 | if ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != |
| 1446 | USB_ENDPOINT_XFER_BULK) { |
| 1447 | brcmf_dbg(ERROR, "invalid data endpoint %d\n", ep); |
| 1448 | ret = -1; |
| 1449 | goto fail; |
| 1450 | } |
| 1451 | |
| 1452 | endpoint_num = endpoint->bEndpointAddress & |
| 1453 | USB_ENDPOINT_NUMBER_MASK; |
| 1454 | if ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) |
| 1455 | == USB_DIR_IN) { |
Hante Meuleman | d74a0b5 | 2012-09-11 21:18:51 +0200 | [diff] [blame] | 1456 | if (!devinfo->rx_pipe) { |
| 1457 | devinfo->rx_pipe = |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1458 | usb_rcvbulkpipe(usb, endpoint_num); |
| 1459 | } else { |
Hante Meuleman | d74a0b5 | 2012-09-11 21:18:51 +0200 | [diff] [blame] | 1460 | devinfo->rx_pipe2 = |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1461 | usb_rcvbulkpipe(usb, endpoint_num); |
| 1462 | } |
| 1463 | } else { |
Hante Meuleman | d74a0b5 | 2012-09-11 21:18:51 +0200 | [diff] [blame] | 1464 | devinfo->tx_pipe = usb_sndbulkpipe(usb, endpoint_num); |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1465 | } |
| 1466 | } |
| 1467 | |
| 1468 | /* Allocate interrupt URB and data buffer */ |
| 1469 | /* RNDIS says 8-byte intr, our old drivers used 4-byte */ |
| 1470 | if (IFEPDESC(usb, CONTROL_IF, 0).wMaxPacketSize == cpu_to_le16(16)) |
Hante Meuleman | d74a0b5 | 2012-09-11 21:18:51 +0200 | [diff] [blame] | 1471 | devinfo->intr_size = 8; |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1472 | else |
Hante Meuleman | d74a0b5 | 2012-09-11 21:18:51 +0200 | [diff] [blame] | 1473 | devinfo->intr_size = 4; |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1474 | |
Hante Meuleman | d74a0b5 | 2012-09-11 21:18:51 +0200 | [diff] [blame] | 1475 | devinfo->interval = IFEPDESC(usb, CONTROL_IF, 0).bInterval; |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1476 | |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1477 | if (usb->speed == USB_SPEED_HIGH) |
| 1478 | brcmf_dbg(INFO, "Broadcom high speed USB wireless device detected\n"); |
| 1479 | else |
| 1480 | brcmf_dbg(INFO, "Broadcom full speed USB wireless device detected\n"); |
| 1481 | |
Hante Meuleman | d74a0b5 | 2012-09-11 21:18:51 +0200 | [diff] [blame] | 1482 | ret = brcmf_usb_probe_cb(devinfo, "", USB_BUS, 0); |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1483 | if (ret) |
| 1484 | goto fail; |
| 1485 | |
| 1486 | /* Success */ |
| 1487 | return 0; |
| 1488 | |
| 1489 | fail: |
| 1490 | brcmf_dbg(ERROR, "failed with errno %d\n", ret); |
Hante Meuleman | d74a0b5 | 2012-09-11 21:18:51 +0200 | [diff] [blame] | 1491 | kfree(devinfo); |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1492 | usb_set_intfdata(intf, NULL); |
| 1493 | return ret; |
| 1494 | |
| 1495 | } |
| 1496 | |
| 1497 | static void |
| 1498 | brcmf_usb_disconnect(struct usb_interface *intf) |
| 1499 | { |
Hante Meuleman | d74a0b5 | 2012-09-11 21:18:51 +0200 | [diff] [blame] | 1500 | struct brcmf_usbdev_info *devinfo; |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1501 | |
| 1502 | brcmf_dbg(TRACE, "enter\n"); |
Hante Meuleman | d74a0b5 | 2012-09-11 21:18:51 +0200 | [diff] [blame] | 1503 | devinfo = (struct brcmf_usbdev_info *)usb_get_intfdata(intf); |
| 1504 | brcmf_usb_disconnect_cb(devinfo); |
| 1505 | kfree(devinfo); |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1506 | } |
| 1507 | |
| 1508 | /* |
| 1509 | * only need to signal the bus being down and update the suspend state. |
| 1510 | */ |
| 1511 | static int brcmf_usb_suspend(struct usb_interface *intf, pm_message_t state) |
| 1512 | { |
| 1513 | struct usb_device *usb = interface_to_usbdev(intf); |
| 1514 | struct brcmf_usbdev_info *devinfo = brcmf_usb_get_businfo(&usb->dev); |
| 1515 | |
| 1516 | brcmf_dbg(TRACE, "enter\n"); |
| 1517 | devinfo->bus_pub.state = BCMFMAC_USB_STATE_DOWN; |
| 1518 | devinfo->suspend_state = USBOS_SUSPEND_STATE_SUSPENDED; |
| 1519 | return 0; |
| 1520 | } |
| 1521 | |
| 1522 | /* |
| 1523 | * mark suspend state active and crank up the bus. |
| 1524 | */ |
| 1525 | static int brcmf_usb_resume(struct usb_interface *intf) |
| 1526 | { |
| 1527 | struct usb_device *usb = interface_to_usbdev(intf); |
| 1528 | struct brcmf_usbdev_info *devinfo = brcmf_usb_get_businfo(&usb->dev); |
| 1529 | |
| 1530 | brcmf_dbg(TRACE, "enter\n"); |
| 1531 | devinfo->suspend_state = USBOS_SUSPEND_STATE_DEVICE_ACTIVE; |
| 1532 | brcmf_bus_start(&usb->dev); |
| 1533 | return 0; |
| 1534 | } |
| 1535 | |
| 1536 | #define BRCMF_USB_VENDOR_ID_BROADCOM 0x0a5c |
Hante Meuleman | 70f0822 | 2012-08-30 19:43:01 +0200 | [diff] [blame] | 1537 | #define BRCMF_USB_DEVICE_ID_43143 0xbd1e |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1538 | #define BRCMF_USB_DEVICE_ID_43236 0xbd17 |
Hante Meuleman | 1212d37 | 2012-08-30 19:43:00 +0200 | [diff] [blame] | 1539 | #define BRCMF_USB_DEVICE_ID_43242 0xbd1f |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1540 | #define BRCMF_USB_DEVICE_ID_BCMFW 0x0bdc |
| 1541 | |
| 1542 | static struct usb_device_id brcmf_usb_devid_table[] = { |
Hante Meuleman | 70f0822 | 2012-08-30 19:43:01 +0200 | [diff] [blame] | 1543 | { USB_DEVICE(BRCMF_USB_VENDOR_ID_BROADCOM, BRCMF_USB_DEVICE_ID_43143) }, |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1544 | { USB_DEVICE(BRCMF_USB_VENDOR_ID_BROADCOM, BRCMF_USB_DEVICE_ID_43236) }, |
Hante Meuleman | 1212d37 | 2012-08-30 19:43:00 +0200 | [diff] [blame] | 1545 | { USB_DEVICE(BRCMF_USB_VENDOR_ID_BROADCOM, BRCMF_USB_DEVICE_ID_43242) }, |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1546 | /* special entry for device with firmware loaded and running */ |
| 1547 | { USB_DEVICE(BRCMF_USB_VENDOR_ID_BROADCOM, BRCMF_USB_DEVICE_ID_BCMFW) }, |
| 1548 | { } |
| 1549 | }; |
| 1550 | MODULE_DEVICE_TABLE(usb, brcmf_usb_devid_table); |
Hante Meuleman | 70f0822 | 2012-08-30 19:43:01 +0200 | [diff] [blame] | 1551 | MODULE_FIRMWARE(BRCMF_USB_43143_FW_NAME); |
Rafał Miłecki | fda8241 | 2012-02-24 07:22:51 +0100 | [diff] [blame] | 1552 | MODULE_FIRMWARE(BRCMF_USB_43236_FW_NAME); |
Hante Meuleman | 1212d37 | 2012-08-30 19:43:00 +0200 | [diff] [blame] | 1553 | MODULE_FIRMWARE(BRCMF_USB_43242_FW_NAME); |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1554 | |
| 1555 | /* TODO: suspend and resume entries */ |
| 1556 | static struct usb_driver brcmf_usbdrvr = { |
| 1557 | .name = KBUILD_MODNAME, |
| 1558 | .probe = brcmf_usb_probe, |
| 1559 | .disconnect = brcmf_usb_disconnect, |
| 1560 | .id_table = brcmf_usb_devid_table, |
| 1561 | .suspend = brcmf_usb_suspend, |
| 1562 | .resume = brcmf_usb_resume, |
Sarah Sharp | c51fa66 | 2012-05-21 05:34:24 -0700 | [diff] [blame] | 1563 | .supports_autosuspend = 1, |
Sarah Sharp | e1f12eb | 2012-04-23 10:08:51 -0700 | [diff] [blame] | 1564 | .disable_hub_initiated_lpm = 1, |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1565 | }; |
| 1566 | |
Hante Meuleman | 803599d | 2012-09-19 22:21:10 +0200 | [diff] [blame] | 1567 | static void brcmf_release_fw(struct list_head *q) |
| 1568 | { |
| 1569 | struct brcmf_usb_image *fw_image, *next; |
| 1570 | |
| 1571 | list_for_each_entry_safe(fw_image, next, q, list) { |
| 1572 | vfree(fw_image->image); |
| 1573 | list_del_init(&fw_image->list); |
| 1574 | } |
| 1575 | } |
| 1576 | |
| 1577 | |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1578 | void brcmf_usb_exit(void) |
| 1579 | { |
| 1580 | usb_deregister(&brcmf_usbdrvr); |
Hante Meuleman | 803599d | 2012-09-19 22:21:10 +0200 | [diff] [blame] | 1581 | brcmf_release_fw(&fw_image_list); |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1582 | } |
| 1583 | |
Arend van Spriel | 549040a | 2012-03-02 22:55:48 +0100 | [diff] [blame] | 1584 | void brcmf_usb_init(void) |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1585 | { |
Hante Meuleman | 803599d | 2012-09-19 22:21:10 +0200 | [diff] [blame] | 1586 | INIT_LIST_HEAD(&fw_image_list); |
Arend van Spriel | 549040a | 2012-03-02 22:55:48 +0100 | [diff] [blame] | 1587 | usb_register(&brcmf_usbdrvr); |
Arend van Spriel | 71bb244 | 2012-02-09 21:09:08 +0100 | [diff] [blame] | 1588 | } |