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