?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
proc: use seq_puts()/seq_putc() where possible
[linux-2.6/next.git] / drivers / net / wireless / libertas / if_usb.c
blob6524c70363d9f507ac137c0482d3ff6094fd0ffd
1 /**
2 * This file contains functions used in USB interface module.
3 */
4 #include <linux/delay.h>
5 #include <linux/moduleparam.h>
6 #include <linux/firmware.h>
7 #include <linux/netdevice.h>
8 #include <linux/slab.h>
9 #include <linux/usb.h>
10
11 #ifdef CONFIG_OLPC
12 #include <asm/olpc.h>
13 #endif
14
15 #define DRV_NAME "usb8xxx"
16
17 #include "host.h"
18 #include "decl.h"
19 #include "defs.h"
20 #include "dev.h"
21 #include "cmd.h"
22 #include "if_usb.h"
23
24 #define INSANEDEBUG 0
25 #define lbs_deb_usb2(...) do { if (INSANEDEBUG) lbs_deb_usbd(__VA_ARGS__); } while (0)
26
27 #define MESSAGE_HEADER_LEN 4
28
29 static char *lbs_fw_name = NULL;
30 module_param_named(fw_name, lbs_fw_name, charp, 0644);
31
32 MODULE_FIRMWARE("libertas/usb8388_v9.bin");
33 MODULE_FIRMWARE("libertas/usb8388_v5.bin");
34 MODULE_FIRMWARE("libertas/usb8388.bin");
35 MODULE_FIRMWARE("libertas/usb8682.bin");
36 MODULE_FIRMWARE("usb8388.bin");
37
38 enum {
39 MODEL_UNKNOWN = 0x0,
40 MODEL_8388 = 0x1,
41 MODEL_8682 = 0x2
42 };
43
44 static struct usb_device_id if_usb_table[] = {
45 /* Enter the device signature inside */
46 { USB_DEVICE(0x1286, 0x2001), .driver_info = MODEL_8388 },
47 { USB_DEVICE(0x05a3, 0x8388), .driver_info = MODEL_8388 },
48 {} /* Terminating entry */
49 };
50
51 MODULE_DEVICE_TABLE(usb, if_usb_table);
52
53 static void if_usb_receive(struct urb *urb);
54 static void if_usb_receive_fwload(struct urb *urb);
55 static int __if_usb_prog_firmware(struct if_usb_card *cardp,
56 const char *fwname, int cmd);
57 static int if_usb_prog_firmware(struct if_usb_card *cardp,
58 const char *fwname, int cmd);
59 static int if_usb_host_to_card(struct lbs_private *priv, uint8_t type,
60 uint8_t *payload, uint16_t nb);
61 static int usb_tx_block(struct if_usb_card *cardp, uint8_t *payload,
62 uint16_t nb);
63 static void if_usb_free(struct if_usb_card *cardp);
64 static int if_usb_submit_rx_urb(struct if_usb_card *cardp);
65 static int if_usb_reset_device(struct if_usb_card *cardp);
66
67 /* sysfs hooks */
68
69 /**
70 * Set function to write firmware to device's persistent memory
71 */
72 static ssize_t if_usb_firmware_set(struct device *dev,
73 struct device_attribute *attr, const char *buf, size_t count)
74 {
75 struct lbs_private *priv = to_net_dev(dev)->ml_priv;
76 struct if_usb_card *cardp = priv->card;
77 int ret;
78
79 BUG_ON(buf == NULL);
80
81 ret = if_usb_prog_firmware(cardp, buf, BOOT_CMD_UPDATE_FW);
82 if (ret == 0)
83 return count;
84
85 return ret;
86 }
87
88 /**
89 * lbs_flash_fw attribute to be exported per ethX interface through sysfs
90 * (/sys/class/net/ethX/lbs_flash_fw). Use this like so to write firmware to
91 * the device's persistent memory:
92 * echo usb8388-5.126.0.p5.bin > /sys/class/net/ethX/lbs_flash_fw
93 */
94 static DEVICE_ATTR(lbs_flash_fw, 0200, NULL, if_usb_firmware_set);
95
96 /**
97 * Set function to write firmware to device's persistent memory
98 */
99 static ssize_t if_usb_boot2_set(struct device *dev,
100 struct device_attribute *attr, const char *buf, size_t count)
101 {
102 struct lbs_private *priv = to_net_dev(dev)->ml_priv;
103 struct if_usb_card *cardp = priv->card;
104 int ret;
105
106 BUG_ON(buf == NULL);
107
108 ret = if_usb_prog_firmware(cardp, buf, BOOT_CMD_UPDATE_BOOT2);
109 if (ret == 0)
110 return count;
111
112 return ret;
113 }
114
115 /**
116 * lbs_flash_boot2 attribute to be exported per ethX interface through sysfs
117 * (/sys/class/net/ethX/lbs_flash_boot2). Use this like so to write firmware
118 * to the device's persistent memory:
119 * echo usb8388-5.126.0.p5.bin > /sys/class/net/ethX/lbs_flash_boot2
120 */
121 static DEVICE_ATTR(lbs_flash_boot2, 0200, NULL, if_usb_boot2_set);
122
123 /**
124 * @brief call back function to handle the status of the URB
125 * @param urb pointer to urb structure
126 * @return N/A
127 */
128 static void if_usb_write_bulk_callback(struct urb *urb)
129 {
130 struct if_usb_card *cardp = (struct if_usb_card *) urb->context;
131
132 /* handle the transmission complete validations */
133
134 if (urb->status == 0) {
135 struct lbs_private *priv = cardp->priv;
136
137 lbs_deb_usb2(&urb->dev->dev, "URB status is successful\n");
138 lbs_deb_usb2(&urb->dev->dev, "Actual length transmitted %d\n",
139 urb->actual_length);
140
141 /* Boot commands such as UPDATE_FW and UPDATE_BOOT2 are not
142 * passed up to the lbs level.
143 */
144 if (priv && priv->dnld_sent != DNLD_BOOTCMD_SENT)
145 lbs_host_to_card_done(priv);
146 } else {
147 /* print the failure status number for debug */
148 lbs_pr_info("URB in failure status: %d\n", urb->status);
149 }
150 }
151
152 /**
153 * @brief free tx/rx urb, skb and rx buffer
154 * @param cardp pointer if_usb_card
155 * @return N/A
156 */
157 static void if_usb_free(struct if_usb_card *cardp)
158 {
159 lbs_deb_enter(LBS_DEB_USB);
160
161 /* Unlink tx & rx urb */
162 usb_kill_urb(cardp->tx_urb);
163 usb_kill_urb(cardp->rx_urb);
164
165 usb_free_urb(cardp->tx_urb);
166 cardp->tx_urb = NULL;
167
168 usb_free_urb(cardp->rx_urb);
169 cardp->rx_urb = NULL;
170
171 kfree(cardp->ep_out_buf);
172 cardp->ep_out_buf = NULL;
173
174 lbs_deb_leave(LBS_DEB_USB);
175 }
176
177 static void if_usb_setup_firmware(struct lbs_private *priv)
178 {
179 struct if_usb_card *cardp = priv->card;
180 struct cmd_ds_set_boot2_ver b2_cmd;
181 struct cmd_ds_802_11_fw_wake_method wake_method;
182
183 b2_cmd.hdr.size = cpu_to_le16(sizeof(b2_cmd));
184 b2_cmd.action = 0;
185 b2_cmd.version = cardp->boot2_version;
186
187 if (lbs_cmd_with_response(priv, CMD_SET_BOOT2_VER, &b2_cmd))
188 lbs_deb_usb("Setting boot2 version failed\n");
189
190 priv->wol_gpio = 2; /* Wake via GPIO2... */
191 priv->wol_gap = 20; /* ... after 20ms */
192 lbs_host_sleep_cfg(priv, EHS_WAKE_ON_UNICAST_DATA,
193 (struct wol_config *) NULL);
194
195 wake_method.hdr.size = cpu_to_le16(sizeof(wake_method));
196 wake_method.action = cpu_to_le16(CMD_ACT_GET);
197 if (lbs_cmd_with_response(priv, CMD_802_11_FW_WAKE_METHOD, &wake_method)) {
198 lbs_pr_info("Firmware does not seem to support PS mode\n");
199 priv->fwcapinfo &= ~FW_CAPINFO_PS;
200 } else {
201 if (le16_to_cpu(wake_method.method) == CMD_WAKE_METHOD_COMMAND_INT) {
202 lbs_deb_usb("Firmware seems to support PS with wake-via-command\n");
203 } else {
204 /* The versions which boot up this way don't seem to
205 work even if we set it to the command interrupt */
206 priv->fwcapinfo &= ~FW_CAPINFO_PS;
207 lbs_pr_info("Firmware doesn't wake via command interrupt; disabling PS mode\n");
208 }
209 }
210 }
211
212 static void if_usb_fw_timeo(unsigned long priv)
213 {
214 struct if_usb_card *cardp = (void *)priv;
215
216 if (cardp->fwdnldover) {
217 lbs_deb_usb("Download complete, no event. Assuming success\n");
218 } else {
219 lbs_pr_err("Download timed out\n");
220 cardp->surprise_removed = 1;
221 }
222 wake_up(&cardp->fw_wq);
223 }
224
225 #ifdef CONFIG_OLPC
226 static void if_usb_reset_olpc_card(struct lbs_private *priv)
227 {
228 printk(KERN_CRIT "Resetting OLPC wireless via EC...\n");
229 olpc_ec_cmd(0x25, NULL, 0, NULL, 0);
230 }
231 #endif
232
233 /**
234 * @brief sets the configuration values
235 * @param ifnum interface number
236 * @param id pointer to usb_device_id
237 * @return 0 on success, error code on failure
238 */
239 static int if_usb_probe(struct usb_interface *intf,
240 const struct usb_device_id *id)
241 {
242 struct usb_device *udev;
243 struct usb_host_interface *iface_desc;
244 struct usb_endpoint_descriptor *endpoint;
245 struct lbs_private *priv;
246 struct if_usb_card *cardp;
247 int i;
248
249 udev = interface_to_usbdev(intf);
250
251 cardp = kzalloc(sizeof(struct if_usb_card), GFP_KERNEL);
252 if (!cardp) {
253 lbs_pr_err("Out of memory allocating private data.\n");
254 goto error;
255 }
256
257 setup_timer(&cardp->fw_timeout, if_usb_fw_timeo, (unsigned long)cardp);
258 init_waitqueue_head(&cardp->fw_wq);
259
260 cardp->udev = udev;
261 cardp->model = (uint32_t) id->driver_info;
262 iface_desc = intf->cur_altsetting;
263
264 lbs_deb_usbd(&udev->dev, "bcdUSB = 0x%X bDeviceClass = 0x%X"
265 " bDeviceSubClass = 0x%X, bDeviceProtocol = 0x%X\n",
266 le16_to_cpu(udev->descriptor.bcdUSB),
267 udev->descriptor.bDeviceClass,
268 udev->descriptor.bDeviceSubClass,
269 udev->descriptor.bDeviceProtocol);
270
271 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
272 endpoint = &iface_desc->endpoint[i].desc;
273 if (usb_endpoint_is_bulk_in(endpoint)) {
274 cardp->ep_in_size = le16_to_cpu(endpoint->wMaxPacketSize);
275 cardp->ep_in = usb_endpoint_num(endpoint);
276
277 lbs_deb_usbd(&udev->dev, "in_endpoint = %d\n", cardp->ep_in);
278 lbs_deb_usbd(&udev->dev, "Bulk in size is %d\n", cardp->ep_in_size);
279
280 } else if (usb_endpoint_is_bulk_out(endpoint)) {
281 cardp->ep_out_size = le16_to_cpu(endpoint->wMaxPacketSize);
282 cardp->ep_out = usb_endpoint_num(endpoint);
283
284 lbs_deb_usbd(&udev->dev, "out_endpoint = %d\n", cardp->ep_out);
285 lbs_deb_usbd(&udev->dev, "Bulk out size is %d\n", cardp->ep_out_size);
286 }
287 }
288 if (!cardp->ep_out_size || !cardp->ep_in_size) {
289 lbs_deb_usbd(&udev->dev, "Endpoints not found\n");
290 goto dealloc;
291 }
292 if (!(cardp->rx_urb = usb_alloc_urb(0, GFP_KERNEL))) {
293 lbs_deb_usbd(&udev->dev, "Rx URB allocation failed\n");
294 goto dealloc;
295 }
296 if (!(cardp->tx_urb = usb_alloc_urb(0, GFP_KERNEL))) {
297 lbs_deb_usbd(&udev->dev, "Tx URB allocation failed\n");
298 goto dealloc;
299 }
300 cardp->ep_out_buf = kmalloc(MRVDRV_ETH_TX_PACKET_BUFFER_SIZE, GFP_KERNEL);
301 if (!cardp->ep_out_buf) {
302 lbs_deb_usbd(&udev->dev, "Could not allocate buffer\n");
303 goto dealloc;
304 }
305
306 /* Upload firmware */
307 kparam_block_sysfs_write(fw_name);
308 if (__if_usb_prog_firmware(cardp, lbs_fw_name, BOOT_CMD_FW_BY_USB)) {
309 kparam_unblock_sysfs_write(fw_name);
310 lbs_deb_usbd(&udev->dev, "FW upload failed\n");
311 goto err_prog_firmware;
312 }
313 kparam_unblock_sysfs_write(fw_name);
314
315 if (!(priv = lbs_add_card(cardp, &udev->dev)))
316 goto err_prog_firmware;
317
318 cardp->priv = priv;
319 cardp->priv->fw_ready = 1;
320
321 priv->hw_host_to_card = if_usb_host_to_card;
322 priv->enter_deep_sleep = NULL;
323 priv->exit_deep_sleep = NULL;
324 priv->reset_deep_sleep_wakeup = NULL;
325 #ifdef CONFIG_OLPC
326 if (machine_is_olpc())
327 priv->reset_card = if_usb_reset_olpc_card;
328 #endif
329
330 cardp->boot2_version = udev->descriptor.bcdDevice;
331
332 if_usb_submit_rx_urb(cardp);
333
334 if (lbs_start_card(priv))
335 goto err_start_card;
336
337 if_usb_setup_firmware(priv);
338
339 usb_get_dev(udev);
340 usb_set_intfdata(intf, cardp);
341
342 if (device_create_file(&priv->dev->dev, &dev_attr_lbs_flash_fw))
343 lbs_pr_err("cannot register lbs_flash_fw attribute\n");
344
345 if (device_create_file(&priv->dev->dev, &dev_attr_lbs_flash_boot2))
346 lbs_pr_err("cannot register lbs_flash_boot2 attribute\n");
347
348 /*
349 * EHS_REMOVE_WAKEUP is not supported on all versions of the firmware.
350 */
351 priv->wol_criteria = EHS_REMOVE_WAKEUP;
352 if (lbs_host_sleep_cfg(priv, priv->wol_criteria, NULL))
353 priv->ehs_remove_supported = false;
354
355 return 0;
356
357 err_start_card:
358 lbs_remove_card(priv);
359 err_prog_firmware:
360 if_usb_reset_device(cardp);
361 dealloc:
362 if_usb_free(cardp);
363
364 error:
365 return -ENOMEM;
366 }
367
368 /**
369 * @brief free resource and cleanup
370 * @param intf USB interface structure
371 * @return N/A
372 */
373 static void if_usb_disconnect(struct usb_interface *intf)
374 {
375 struct if_usb_card *cardp = usb_get_intfdata(intf);
376 struct lbs_private *priv = (struct lbs_private *) cardp->priv;
377
378 lbs_deb_enter(LBS_DEB_MAIN);
379
380 device_remove_file(&priv->dev->dev, &dev_attr_lbs_flash_boot2);
381 device_remove_file(&priv->dev->dev, &dev_attr_lbs_flash_fw);
382
383 cardp->surprise_removed = 1;
384
385 if (priv) {
386 priv->surpriseremoved = 1;
387 lbs_stop_card(priv);
388 lbs_remove_card(priv);
389 }
390
391 /* Unlink and free urb */
392 if_usb_free(cardp);
393
394 usb_set_intfdata(intf, NULL);
395 usb_put_dev(interface_to_usbdev(intf));
396
397 lbs_deb_leave(LBS_DEB_MAIN);
398 }
399
400 /**
401 * @brief This function download FW
402 * @param priv pointer to struct lbs_private
403 * @return 0
404 */
405 static int if_usb_send_fw_pkt(struct if_usb_card *cardp)
406 {
407 struct fwdata *fwdata = cardp->ep_out_buf;
408 const uint8_t *firmware = cardp->fw->data;
409
410 /* If we got a CRC failure on the last block, back
411 up and retry it */
412 if (!cardp->CRC_OK) {
413 cardp->totalbytes = cardp->fwlastblksent;
414 cardp->fwseqnum--;
415 }
416
417 lbs_deb_usb2(&cardp->udev->dev, "totalbytes = %d\n",
418 cardp->totalbytes);
419
420 /* struct fwdata (which we sent to the card) has an
421 extra __le32 field in between the header and the data,
422 which is not in the struct fwheader in the actual
423 firmware binary. Insert the seqnum in the middle... */
424 memcpy(&fwdata->hdr, &firmware[cardp->totalbytes],
425 sizeof(struct fwheader));
426
427 cardp->fwlastblksent = cardp->totalbytes;
428 cardp->totalbytes += sizeof(struct fwheader);
429
430 memcpy(fwdata->data, &firmware[cardp->totalbytes],
431 le32_to_cpu(fwdata->hdr.datalength));
432
433 lbs_deb_usb2(&cardp->udev->dev, "Data length = %d\n",
434 le32_to_cpu(fwdata->hdr.datalength));
435
436 fwdata->seqnum = cpu_to_le32(++cardp->fwseqnum);
437 cardp->totalbytes += le32_to_cpu(fwdata->hdr.datalength);
438
439 usb_tx_block(cardp, cardp->ep_out_buf, sizeof(struct fwdata) +
440 le32_to_cpu(fwdata->hdr.datalength));
441
442 if (fwdata->hdr.dnldcmd == cpu_to_le32(FW_HAS_DATA_TO_RECV)) {
443 lbs_deb_usb2(&cardp->udev->dev, "There are data to follow\n");
444 lbs_deb_usb2(&cardp->udev->dev, "seqnum = %d totalbytes = %d\n",
445 cardp->fwseqnum, cardp->totalbytes);
446 } else if (fwdata->hdr.dnldcmd == cpu_to_le32(FW_HAS_LAST_BLOCK)) {
447 lbs_deb_usb2(&cardp->udev->dev, "Host has finished FW downloading\n");
448 lbs_deb_usb2(&cardp->udev->dev, "Donwloading FW JUMP BLOCK\n");
449
450 cardp->fwfinalblk = 1;
451 }
452
453 lbs_deb_usb2(&cardp->udev->dev, "Firmware download done; size %d\n",
454 cardp->totalbytes);
455
456 return 0;
457 }
458
459 static int if_usb_reset_device(struct if_usb_card *cardp)
460 {
461 struct cmd_header *cmd = cardp->ep_out_buf + 4;
462 int ret;
463
464 lbs_deb_enter(LBS_DEB_USB);
465
466 *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_REQUEST);
467
468 cmd->command = cpu_to_le16(CMD_802_11_RESET);
469 cmd->size = cpu_to_le16(sizeof(cmd));
470 cmd->result = cpu_to_le16(0);
471 cmd->seqnum = cpu_to_le16(0x5a5a);
472 usb_tx_block(cardp, cardp->ep_out_buf, 4 + sizeof(struct cmd_header));
473
474 msleep(100);
475 ret = usb_reset_device(cardp->udev);
476 msleep(100);
477
478 #ifdef CONFIG_OLPC
479 if (ret && machine_is_olpc())
480 if_usb_reset_olpc_card(NULL);
481 #endif
482
483 lbs_deb_leave_args(LBS_DEB_USB, "ret %d", ret);
484
485 return ret;
486 }
487
488 /**
489 * @brief This function transfer the data to the device.
490 * @param priv pointer to struct lbs_private
491 * @param payload pointer to payload data
492 * @param nb data length
493 * @return 0 or -1
494 */
495 static int usb_tx_block(struct if_usb_card *cardp, uint8_t *payload, uint16_t nb)
496 {
497 int ret;
498
499 /* check if device is removed */
500 if (cardp->surprise_removed) {
501 lbs_deb_usbd(&cardp->udev->dev, "Device removed\n");
502 ret = -ENODEV;
503 goto tx_ret;
504 }
505
506 usb_fill_bulk_urb(cardp->tx_urb, cardp->udev,
507 usb_sndbulkpipe(cardp->udev,
508 cardp->ep_out),
509 payload, nb, if_usb_write_bulk_callback, cardp);
510
511 cardp->tx_urb->transfer_flags |= URB_ZERO_PACKET;
512
513 if ((ret = usb_submit_urb(cardp->tx_urb, GFP_ATOMIC))) {
514 lbs_deb_usbd(&cardp->udev->dev, "usb_submit_urb failed: %d\n", ret);
515 } else {
516 lbs_deb_usb2(&cardp->udev->dev, "usb_submit_urb success\n");
517 ret = 0;
518 }
519
520 tx_ret:
521 return ret;
522 }
523
524 static int __if_usb_submit_rx_urb(struct if_usb_card *cardp,
525 void (*callbackfn)(struct urb *urb))
526 {
527 struct sk_buff *skb;
528 int ret = -1;
529
530 if (!(skb = dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE))) {
531 lbs_pr_err("No free skb\n");
532 goto rx_ret;
533 }
534
535 cardp->rx_skb = skb;
536
537 /* Fill the receive configuration URB and initialise the Rx call back */
538 usb_fill_bulk_urb(cardp->rx_urb, cardp->udev,
539 usb_rcvbulkpipe(cardp->udev, cardp->ep_in),
540 skb->data + IPFIELD_ALIGN_OFFSET,
541 MRVDRV_ETH_RX_PACKET_BUFFER_SIZE, callbackfn,
542 cardp);
543
544 cardp->rx_urb->transfer_flags |= URB_ZERO_PACKET;
545
546 lbs_deb_usb2(&cardp->udev->dev, "Pointer for rx_urb %p\n", cardp->rx_urb);
547 if ((ret = usb_submit_urb(cardp->rx_urb, GFP_ATOMIC))) {
548 lbs_deb_usbd(&cardp->udev->dev, "Submit Rx URB failed: %d\n", ret);
549 kfree_skb(skb);
550 cardp->rx_skb = NULL;
551 ret = -1;
552 } else {
553 lbs_deb_usb2(&cardp->udev->dev, "Submit Rx URB success\n");
554 ret = 0;
555 }
556
557 rx_ret:
558 return ret;
559 }
560
561 static int if_usb_submit_rx_urb_fwload(struct if_usb_card *cardp)
562 {
563 return __if_usb_submit_rx_urb(cardp, &if_usb_receive_fwload);
564 }
565
566 static int if_usb_submit_rx_urb(struct if_usb_card *cardp)
567 {
568 return __if_usb_submit_rx_urb(cardp, &if_usb_receive);
569 }
570
571 static void if_usb_receive_fwload(struct urb *urb)
572 {
573 struct if_usb_card *cardp = urb->context;
574 struct sk_buff *skb = cardp->rx_skb;
575 struct fwsyncheader *syncfwheader;
576 struct bootcmdresp bootcmdresp;
577
578 if (urb->status) {
579 lbs_deb_usbd(&cardp->udev->dev,
580 "URB status is failed during fw load\n");
581 kfree_skb(skb);
582 return;
583 }
584
585 if (cardp->fwdnldover) {
586 __le32 *tmp = (__le32 *)(skb->data + IPFIELD_ALIGN_OFFSET);
587
588 if (tmp[0] == cpu_to_le32(CMD_TYPE_INDICATION) &&
589 tmp[1] == cpu_to_le32(MACREG_INT_CODE_FIRMWARE_READY)) {
590 lbs_pr_info("Firmware ready event received\n");
591 wake_up(&cardp->fw_wq);
592 } else {
593 lbs_deb_usb("Waiting for confirmation; got %x %x\n",
594 le32_to_cpu(tmp[0]), le32_to_cpu(tmp[1]));
595 if_usb_submit_rx_urb_fwload(cardp);
596 }
597 kfree_skb(skb);
598 return;
599 }
600 if (cardp->bootcmdresp <= 0) {
601 memcpy (&bootcmdresp, skb->data + IPFIELD_ALIGN_OFFSET,
602 sizeof(bootcmdresp));
603
604 if (le16_to_cpu(cardp->udev->descriptor.bcdDevice) < 0x3106) {
605 kfree_skb(skb);
606 if_usb_submit_rx_urb_fwload(cardp);
607 cardp->bootcmdresp = BOOT_CMD_RESP_OK;
608 lbs_deb_usbd(&cardp->udev->dev,
609 "Received valid boot command response\n");
610 return;
611 }
612 if (bootcmdresp.magic != cpu_to_le32(BOOT_CMD_MAGIC_NUMBER)) {
613 if (bootcmdresp.magic == cpu_to_le32(CMD_TYPE_REQUEST) ||
614 bootcmdresp.magic == cpu_to_le32(CMD_TYPE_DATA) ||
615 bootcmdresp.magic == cpu_to_le32(CMD_TYPE_INDICATION)) {
616 if (!cardp->bootcmdresp)
617 lbs_pr_info("Firmware already seems alive; resetting\n");
618 cardp->bootcmdresp = -1;
619 } else {
620 lbs_pr_info("boot cmd response wrong magic number (0x%x)\n",
621 le32_to_cpu(bootcmdresp.magic));
622 }
623 } else if ((bootcmdresp.cmd != BOOT_CMD_FW_BY_USB) &&
624 (bootcmdresp.cmd != BOOT_CMD_UPDATE_FW) &&
625 (bootcmdresp.cmd != BOOT_CMD_UPDATE_BOOT2)) {
626 lbs_pr_info("boot cmd response cmd_tag error (%d)\n",
627 bootcmdresp.cmd);
628 } else if (bootcmdresp.result != BOOT_CMD_RESP_OK) {
629 lbs_pr_info("boot cmd response result error (%d)\n",
630 bootcmdresp.result);
631 } else {
632 cardp->bootcmdresp = 1;
633 lbs_deb_usbd(&cardp->udev->dev,
634 "Received valid boot command response\n");
635 }
636 kfree_skb(skb);
637 if_usb_submit_rx_urb_fwload(cardp);
638 return;
639 }
640
641 syncfwheader = kmemdup(skb->data + IPFIELD_ALIGN_OFFSET,
642 sizeof(struct fwsyncheader), GFP_ATOMIC);
643 if (!syncfwheader) {
644 lbs_deb_usbd(&cardp->udev->dev, "Failure to allocate syncfwheader\n");
645 kfree_skb(skb);
646 return;
647 }
648
649 if (!syncfwheader->cmd) {
650 lbs_deb_usb2(&cardp->udev->dev, "FW received Blk with correct CRC\n");
651 lbs_deb_usb2(&cardp->udev->dev, "FW received Blk seqnum = %d\n",
652 le32_to_cpu(syncfwheader->seqnum));
653 cardp->CRC_OK = 1;
654 } else {
655 lbs_deb_usbd(&cardp->udev->dev, "FW received Blk with CRC error\n");
656 cardp->CRC_OK = 0;
657 }
658
659 kfree_skb(skb);
660
661 /* Give device 5s to either write firmware to its RAM or eeprom */
662 mod_timer(&cardp->fw_timeout, jiffies + (HZ*5));
663
664 if (cardp->fwfinalblk) {
665 cardp->fwdnldover = 1;
666 goto exit;
667 }
668
669 if_usb_send_fw_pkt(cardp);
670
671 exit:
672 if_usb_submit_rx_urb_fwload(cardp);
673
674 kfree(syncfwheader);
675 }
676
677 #define MRVDRV_MIN_PKT_LEN 30
678
679 static inline void process_cmdtypedata(int recvlength, struct sk_buff *skb,
680 struct if_usb_card *cardp,
681 struct lbs_private *priv)
682 {
683 if (recvlength > MRVDRV_ETH_RX_PACKET_BUFFER_SIZE + MESSAGE_HEADER_LEN
684 || recvlength < MRVDRV_MIN_PKT_LEN) {
685 lbs_deb_usbd(&cardp->udev->dev, "Packet length is Invalid\n");
686 kfree_skb(skb);
687 return;
688 }
689
690 skb_reserve(skb, IPFIELD_ALIGN_OFFSET);
691 skb_put(skb, recvlength);
692 skb_pull(skb, MESSAGE_HEADER_LEN);
693
694 lbs_process_rxed_packet(priv, skb);
695 }
696
697 static inline void process_cmdrequest(int recvlength, uint8_t *recvbuff,
698 struct sk_buff *skb,
699 struct if_usb_card *cardp,
700 struct lbs_private *priv)
701 {
702 u8 i;
703
704 if (recvlength > LBS_CMD_BUFFER_SIZE) {
705 lbs_deb_usbd(&cardp->udev->dev,
706 "The receive buffer is too large\n");
707 kfree_skb(skb);
708 return;
709 }
710
711 BUG_ON(!in_interrupt());
712
713 spin_lock(&priv->driver_lock);
714
715 i = (priv->resp_idx == 0) ? 1 : 0;
716 BUG_ON(priv->resp_len[i]);
717 priv->resp_len[i] = (recvlength - MESSAGE_HEADER_LEN);
718 memcpy(priv->resp_buf[i], recvbuff + MESSAGE_HEADER_LEN,
719 priv->resp_len[i]);
720 kfree_skb(skb);
721 lbs_notify_command_response(priv, i);
722
723 spin_unlock(&priv->driver_lock);
724
725 lbs_deb_usbd(&cardp->udev->dev,
726 "Wake up main thread to handle cmd response\n");
727 }
728
729 /**
730 * @brief This function reads of the packet into the upload buff,
731 * wake up the main thread and initialise the Rx callack.
732 *
733 * @param urb pointer to struct urb
734 * @return N/A
735 */
736 static void if_usb_receive(struct urb *urb)
737 {
738 struct if_usb_card *cardp = urb->context;
739 struct sk_buff *skb = cardp->rx_skb;
740 struct lbs_private *priv = cardp->priv;
741 int recvlength = urb->actual_length;
742 uint8_t *recvbuff = NULL;
743 uint32_t recvtype = 0;
744 __le32 *pkt = (__le32 *)(skb->data + IPFIELD_ALIGN_OFFSET);
745 uint32_t event;
746
747 lbs_deb_enter(LBS_DEB_USB);
748
749 if (recvlength) {
750 if (urb->status) {
751 lbs_deb_usbd(&cardp->udev->dev, "RX URB failed: %d\n",
752 urb->status);
753 kfree_skb(skb);
754 goto setup_for_next;
755 }
756
757 recvbuff = skb->data + IPFIELD_ALIGN_OFFSET;
758 recvtype = le32_to_cpu(pkt[0]);
759 lbs_deb_usbd(&cardp->udev->dev,
760 "Recv length = 0x%x, Recv type = 0x%X\n",
761 recvlength, recvtype);
762 } else if (urb->status) {
763 kfree_skb(skb);
764 goto rx_exit;
765 }
766
767 switch (recvtype) {
768 case CMD_TYPE_DATA:
769 process_cmdtypedata(recvlength, skb, cardp, priv);
770 break;
771
772 case CMD_TYPE_REQUEST:
773 process_cmdrequest(recvlength, recvbuff, skb, cardp, priv);
774 break;
775
776 case CMD_TYPE_INDICATION:
777 /* Event handling */
778 event = le32_to_cpu(pkt[1]);
779 lbs_deb_usbd(&cardp->udev->dev, "**EVENT** 0x%X\n", event);
780 kfree_skb(skb);
781
782 /* Icky undocumented magic special case */
783 if (event & 0xffff0000) {
784 u32 trycount = (event & 0xffff0000) >> 16;
785
786 lbs_send_tx_feedback(priv, trycount);
787 } else
788 lbs_queue_event(priv, event & 0xFF);
789 break;
790
791 default:
792 lbs_deb_usbd(&cardp->udev->dev, "Unknown command type 0x%X\n",
793 recvtype);
794 kfree_skb(skb);
795 break;
796 }
797
798 setup_for_next:
799 if_usb_submit_rx_urb(cardp);
800 rx_exit:
801 lbs_deb_leave(LBS_DEB_USB);
802 }
803
804 /**
805 * @brief This function downloads data to FW
806 * @param priv pointer to struct lbs_private structure
807 * @param type type of data
808 * @param buf pointer to data buffer
809 * @param len number of bytes
810 * @return 0 or -1
811 */
812 static int if_usb_host_to_card(struct lbs_private *priv, uint8_t type,
813 uint8_t *payload, uint16_t nb)
814 {
815 struct if_usb_card *cardp = priv->card;
816
817 lbs_deb_usbd(&cardp->udev->dev,"*** type = %u\n", type);
818 lbs_deb_usbd(&cardp->udev->dev,"size after = %d\n", nb);
819
820 if (type == MVMS_CMD) {
821 *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_REQUEST);
822 priv->dnld_sent = DNLD_CMD_SENT;
823 } else {
824 *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_DATA);
825 priv->dnld_sent = DNLD_DATA_SENT;
826 }
827
828 memcpy((cardp->ep_out_buf + MESSAGE_HEADER_LEN), payload, nb);
829
830 return usb_tx_block(cardp, cardp->ep_out_buf, nb + MESSAGE_HEADER_LEN);
831 }
832
833 /**
834 * @brief This function issues Boot command to the Boot2 code
835 * @param ivalue 1:Boot from FW by USB-Download
836 * 2:Boot from FW in EEPROM
837 * @return 0
838 */
839 static int if_usb_issue_boot_command(struct if_usb_card *cardp, int ivalue)
840 {
841 struct bootcmd *bootcmd = cardp->ep_out_buf;
842
843 /* Prepare command */
844 bootcmd->magic = cpu_to_le32(BOOT_CMD_MAGIC_NUMBER);
845 bootcmd->cmd = ivalue;
846 memset(bootcmd->pad, 0, sizeof(bootcmd->pad));
847
848 /* Issue command */
849 usb_tx_block(cardp, cardp->ep_out_buf, sizeof(*bootcmd));
850
851 return 0;
852 }
853
854
855 /**
856 * @brief This function checks the validity of Boot2/FW image.
857 *
858 * @param data pointer to image
859 * len image length
860 * @return 0 or -1
861 */
862 static int check_fwfile_format(const uint8_t *data, uint32_t totlen)
863 {
864 uint32_t bincmd, exit;
865 uint32_t blksize, offset, len;
866 int ret;
867
868 ret = 1;
869 exit = len = 0;
870
871 do {
872 struct fwheader *fwh = (void *)data;
873
874 bincmd = le32_to_cpu(fwh->dnldcmd);
875 blksize = le32_to_cpu(fwh->datalength);
876 switch (bincmd) {
877 case FW_HAS_DATA_TO_RECV:
878 offset = sizeof(struct fwheader) + blksize;
879 data += offset;
880 len += offset;
881 if (len >= totlen)
882 exit = 1;
883 break;
884 case FW_HAS_LAST_BLOCK:
885 exit = 1;
886 ret = 0;
887 break;
888 default:
889 exit = 1;
890 break;
891 }
892 } while (!exit);
893
894 if (ret)
895 lbs_pr_err("firmware file format check FAIL\n");
896 else
897 lbs_deb_fw("firmware file format check PASS\n");
898
899 return ret;
900 }
901
902
903 /**
904 * @brief This function programs the firmware subject to cmd
905 *
906 * @param cardp the if_usb_card descriptor
907 * fwname firmware or boot2 image file name
908 * cmd either BOOT_CMD_FW_BY_USB, BOOT_CMD_UPDATE_FW,
909 * or BOOT_CMD_UPDATE_BOOT2.
910 * @return 0 or error code
911 */
912 static int if_usb_prog_firmware(struct if_usb_card *cardp,
913 const char *fwname, int cmd)
914 {
915 struct lbs_private *priv = cardp->priv;
916 unsigned long flags, caps;
917 int ret;
918
919 caps = priv->fwcapinfo;
920 if (((cmd == BOOT_CMD_UPDATE_FW) && !(caps & FW_CAPINFO_FIRMWARE_UPGRADE)) ||
921 ((cmd == BOOT_CMD_UPDATE_BOOT2) && !(caps & FW_CAPINFO_BOOT2_UPGRADE)))
922 return -EOPNOTSUPP;
923
924 /* Ensure main thread is idle. */
925 spin_lock_irqsave(&priv->driver_lock, flags);
926 while (priv->cur_cmd != NULL || priv->dnld_sent != DNLD_RES_RECEIVED) {
927 spin_unlock_irqrestore(&priv->driver_lock, flags);
928 if (wait_event_interruptible(priv->waitq,
929 (priv->cur_cmd == NULL &&
930 priv->dnld_sent == DNLD_RES_RECEIVED))) {
931 return -ERESTARTSYS;
932 }
933 spin_lock_irqsave(&priv->driver_lock, flags);
934 }
935 priv->dnld_sent = DNLD_BOOTCMD_SENT;
936 spin_unlock_irqrestore(&priv->driver_lock, flags);
937
938 ret = __if_usb_prog_firmware(cardp, fwname, cmd);
939
940 spin_lock_irqsave(&priv->driver_lock, flags);
941 priv->dnld_sent = DNLD_RES_RECEIVED;
942 spin_unlock_irqrestore(&priv->driver_lock, flags);
943
944 wake_up_interruptible(&priv->waitq);
945
946 return ret;
947 }
948
949 /* table of firmware file names */
950 static const struct {
951 u32 model;
952 const char *fwname;
953 } fw_table[] = {
954 { MODEL_8388, "libertas/usb8388_v9.bin" },
955 { MODEL_8388, "libertas/usb8388_v5.bin" },
956 { MODEL_8388, "libertas/usb8388.bin" },
957 { MODEL_8388, "usb8388.bin" },
958 { MODEL_8682, "libertas/usb8682.bin" }
959 };
960
961 static int get_fw(struct if_usb_card *cardp, const char *fwname)
962 {
963 int i;
964
965 /* Try user-specified firmware first */
966 if (fwname)
967 return request_firmware(&cardp->fw, fwname, &cardp->udev->dev);
968
969 /* Otherwise search for firmware to use */
970 for (i = 0; i < ARRAY_SIZE(fw_table); i++) {
971 if (fw_table[i].model != cardp->model)
972 continue;
973 if (request_firmware(&cardp->fw, fw_table[i].fwname,
974 &cardp->udev->dev) == 0)
975 return 0;
976 }
977
978 return -ENOENT;
979 }
980
981 static int __if_usb_prog_firmware(struct if_usb_card *cardp,
982 const char *fwname, int cmd)
983 {
984 int i = 0;
985 static int reset_count = 10;
986 int ret = 0;
987
988 lbs_deb_enter(LBS_DEB_USB);
989
990 ret = get_fw(cardp, fwname);
991 if (ret) {
992 lbs_pr_err("failed to find firmware (%d)\n", ret);
993 goto done;
994 }
995
996 if (check_fwfile_format(cardp->fw->data, cardp->fw->size)) {
997 ret = -EINVAL;
998 goto release_fw;
999 }
1000
1001 /* Cancel any pending usb business */
1002 usb_kill_urb(cardp->rx_urb);
1003 usb_kill_urb(cardp->tx_urb);
1004
1005 cardp->fwlastblksent = 0;
1006 cardp->fwdnldover = 0;
1007 cardp->totalbytes = 0;
1008 cardp->fwfinalblk = 0;
1009 cardp->bootcmdresp = 0;
1010
1011 restart:
1012 if (if_usb_submit_rx_urb_fwload(cardp) < 0) {
1013 lbs_deb_usbd(&cardp->udev->dev, "URB submission is failed\n");
1014 ret = -EIO;
1015 goto release_fw;
1016 }
1017
1018 cardp->bootcmdresp = 0;
1019 do {
1020 int j = 0;
1021 i++;
1022 if_usb_issue_boot_command(cardp, cmd);
1023 /* wait for command response */
1024 do {
1025 j++;
1026 msleep_interruptible(100);
1027 } while (cardp->bootcmdresp == 0 && j < 10);
1028 } while (cardp->bootcmdresp == 0 && i < 5);
1029
1030 if (cardp->bootcmdresp == BOOT_CMD_RESP_NOT_SUPPORTED) {
1031 /* Return to normal operation */
1032 ret = -EOPNOTSUPP;
1033 usb_kill_urb(cardp->rx_urb);
1034 usb_kill_urb(cardp->tx_urb);
1035 if (if_usb_submit_rx_urb(cardp) < 0)
1036 ret = -EIO;
1037 goto release_fw;
1038 } else if (cardp->bootcmdresp <= 0) {
1039 if (--reset_count >= 0) {
1040 if_usb_reset_device(cardp);
1041 goto restart;
1042 }
1043 ret = -EIO;
1044 goto release_fw;
1045 }
1046
1047 i = 0;
1048
1049 cardp->totalbytes = 0;
1050 cardp->fwlastblksent = 0;
1051 cardp->CRC_OK = 1;
1052 cardp->fwdnldover = 0;
1053 cardp->fwseqnum = -1;
1054 cardp->totalbytes = 0;
1055 cardp->fwfinalblk = 0;
1056
1057 /* Send the first firmware packet... */
1058 if_usb_send_fw_pkt(cardp);
1059
1060 /* ... and wait for the process to complete */
1061 wait_event_interruptible(cardp->fw_wq, cardp->surprise_removed || cardp->fwdnldover);
1062
1063 del_timer_sync(&cardp->fw_timeout);
1064 usb_kill_urb(cardp->rx_urb);
1065
1066 if (!cardp->fwdnldover) {
1067 lbs_pr_info("failed to load fw, resetting device!\n");
1068 if (--reset_count >= 0) {
1069 if_usb_reset_device(cardp);
1070 goto restart;
1071 }
1072
1073 lbs_pr_info("FW download failure, time = %d ms\n", i * 100);
1074 ret = -EIO;
1075 goto release_fw;
1076 }
1077
1078 release_fw:
1079 release_firmware(cardp->fw);
1080 cardp->fw = NULL;
1081
1082 done:
1083 lbs_deb_leave_args(LBS_DEB_USB, "ret %d", ret);
1084 return ret;
1085 }
1086
1087
1088 #ifdef CONFIG_PM
1089 static int if_usb_suspend(struct usb_interface *intf, pm_message_t message)
1090 {
1091 struct if_usb_card *cardp = usb_get_intfdata(intf);
1092 struct lbs_private *priv = cardp->priv;
1093 int ret;
1094
1095 lbs_deb_enter(LBS_DEB_USB);
1096
1097 if (priv->psstate != PS_STATE_FULL_POWER)
1098 return -1;
1099
1100 ret = lbs_suspend(priv);
1101 if (ret)
1102 goto out;
1103
1104 /* Unlink tx & rx urb */
1105 usb_kill_urb(cardp->tx_urb);
1106 usb_kill_urb(cardp->rx_urb);
1107
1108 out:
1109 lbs_deb_leave(LBS_DEB_USB);
1110 return ret;
1111 }
1112
1113 static int if_usb_resume(struct usb_interface *intf)
1114 {
1115 struct if_usb_card *cardp = usb_get_intfdata(intf);
1116 struct lbs_private *priv = cardp->priv;
1117
1118 lbs_deb_enter(LBS_DEB_USB);
1119
1120 if_usb_submit_rx_urb(cardp);
1121
1122 lbs_resume(priv);
1123
1124 lbs_deb_leave(LBS_DEB_USB);
1125 return 0;
1126 }
1127 #else
1128 #define if_usb_suspend NULL
1129 #define if_usb_resume NULL
1130 #endif
1131
1132 static struct usb_driver if_usb_driver = {
1133 .name = DRV_NAME,
1134 .probe = if_usb_probe,
1135 .disconnect = if_usb_disconnect,
1136 .id_table = if_usb_table,
1137 .suspend = if_usb_suspend,
1138 .resume = if_usb_resume,
1139 .reset_resume = if_usb_resume,
1140 };
1141
1142 static int __init if_usb_init_module(void)
1143 {
1144 int ret = 0;
1145
1146 lbs_deb_enter(LBS_DEB_MAIN);
1147
1148 ret = usb_register(&if_usb_driver);
1149
1150 lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret);
1151 return ret;
1152 }
1153
1154 static void __exit if_usb_exit_module(void)
1155 {
1156 lbs_deb_enter(LBS_DEB_MAIN);
1157
1158 usb_deregister(&if_usb_driver);
1159
1160 lbs_deb_leave(LBS_DEB_MAIN);
1161 }
1162
1163 module_init(if_usb_init_module);
1164 module_exit(if_usb_exit_module);
1165
1166 MODULE_DESCRIPTION("8388 USB WLAN Driver");
1167 MODULE_AUTHOR("Marvell International Ltd. and Red Hat, Inc.");
1168 MODULE_LICENSE("GPL");
linux-next