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