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