diff options
author | Linus Torvalds <torvalds@linux-foundation.org> | 2010-05-21 00:04:44 -0400 |
---|---|---|
committer | Linus Torvalds <torvalds@linux-foundation.org> | 2010-05-21 00:04:44 -0400 |
commit | f8965467f366fd18f01feafb5db10512d7b4422c (patch) | |
tree | 3706a9cd779859271ca61b85c63a1bc3f82d626e /drivers/net/wireless/libertas_tf/if_usb.c | |
parent | a26272e5200765691e67d6780e52b32498fdb659 (diff) | |
parent | 2ec8c6bb5d8f3a62a79f463525054bae1e3d4487 (diff) |
Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next-2.6
* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next-2.6: (1674 commits)
qlcnic: adding co maintainer
ixgbe: add support for active DA cables
ixgbe: dcb, do not tag tc_prio_control frames
ixgbe: fix ixgbe_tx_is_paused logic
ixgbe: always enable vlan strip/insert when DCB is enabled
ixgbe: remove some redundant code in setting FCoE FIP filter
ixgbe: fix wrong offset to fc_frame_header in ixgbe_fcoe_ddp
ixgbe: fix header len when unsplit packet overflows to data buffer
ipv6: Never schedule DAD timer on dead address
ipv6: Use POSTDAD state
ipv6: Use state_lock to protect ifa state
ipv6: Replace inet6_ifaddr->dead with state
cxgb4: notify upper drivers if the device is already up when they load
cxgb4: keep interrupts available when the ports are brought down
cxgb4: fix initial addition of MAC address
cnic: Return SPQ credit to bnx2x after ring setup and shutdown.
cnic: Convert cnic_local_flags to atomic ops.
can: Fix SJA1000 command register writes on SMP systems
bridge: fix build for CONFIG_SYSFS disabled
ARCNET: Limit com20020 PCI ID matches for SOHARD cards
...
Fix up various conflicts with pcmcia tree drivers/net/
{pcmcia/3c589_cs.c, wireless/orinoco/orinoco_cs.c and
wireless/orinoco/spectrum_cs.c} and feature removal
(Documentation/feature-removal-schedule.txt).
Also fix a non-content conflict due to pm_qos_requirement getting
renamed in the PM tree (now pm_qos_request) in net/mac80211/scan.c
Diffstat (limited to 'drivers/net/wireless/libertas_tf/if_usb.c')
-rw-r--r-- | drivers/net/wireless/libertas_tf/if_usb.c | 252 |
1 files changed, 210 insertions, 42 deletions
diff --git a/drivers/net/wireless/libertas_tf/if_usb.c b/drivers/net/wireless/libertas_tf/if_usb.c index 8cc9db60c14b..c445500ffc61 100644 --- a/drivers/net/wireless/libertas_tf/if_usb.c +++ b/drivers/net/wireless/libertas_tf/if_usb.c | |||
@@ -7,6 +7,13 @@ | |||
7 | * the Free Software Foundation; either version 2 of the License, or (at | 7 | * the Free Software Foundation; either version 2 of the License, or (at |
8 | * your option) any later version. | 8 | * your option) any later version. |
9 | */ | 9 | */ |
10 | #define DRV_NAME "lbtf_usb" | ||
11 | |||
12 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt | ||
13 | |||
14 | #include "libertas_tf.h" | ||
15 | #include "if_usb.h" | ||
16 | |||
10 | #include <linux/delay.h> | 17 | #include <linux/delay.h> |
11 | #include <linux/moduleparam.h> | 18 | #include <linux/moduleparam.h> |
12 | #include <linux/firmware.h> | 19 | #include <linux/firmware.h> |
@@ -14,10 +21,8 @@ | |||
14 | #include <linux/slab.h> | 21 | #include <linux/slab.h> |
15 | #include <linux/usb.h> | 22 | #include <linux/usb.h> |
16 | 23 | ||
17 | #define DRV_NAME "lbtf_usb" | 24 | #define INSANEDEBUG 0 |
18 | 25 | #define lbtf_deb_usb2(...) do { if (INSANEDEBUG) lbtf_deb_usbd(__VA_ARGS__); } while (0) | |
19 | #include "libertas_tf.h" | ||
20 | #include "if_usb.h" | ||
21 | 26 | ||
22 | #define MESSAGE_HEADER_LEN 4 | 27 | #define MESSAGE_HEADER_LEN 4 |
23 | 28 | ||
@@ -53,9 +58,14 @@ static int if_usb_reset_device(struct if_usb_card *cardp); | |||
53 | */ | 58 | */ |
54 | static void if_usb_write_bulk_callback(struct urb *urb) | 59 | static void if_usb_write_bulk_callback(struct urb *urb) |
55 | { | 60 | { |
56 | if (urb->status != 0) | 61 | if (urb->status != 0) { |
57 | printk(KERN_INFO "libertastf: URB in failure status: %d\n", | 62 | /* print the failure status number for debug */ |
58 | urb->status); | 63 | pr_info("URB in failure status: %d\n", urb->status); |
64 | } else { | ||
65 | lbtf_deb_usb2(&urb->dev->dev, "URB status is successful\n"); | ||
66 | lbtf_deb_usb2(&urb->dev->dev, "Actual length transmitted %d\n", | ||
67 | urb->actual_length); | ||
68 | } | ||
59 | } | 69 | } |
60 | 70 | ||
61 | /** | 71 | /** |
@@ -65,6 +75,8 @@ static void if_usb_write_bulk_callback(struct urb *urb) | |||
65 | */ | 75 | */ |
66 | static void if_usb_free(struct if_usb_card *cardp) | 76 | static void if_usb_free(struct if_usb_card *cardp) |
67 | { | 77 | { |
78 | lbtf_deb_enter(LBTF_DEB_USB); | ||
79 | |||
68 | /* Unlink tx & rx urb */ | 80 | /* Unlink tx & rx urb */ |
69 | usb_kill_urb(cardp->tx_urb); | 81 | usb_kill_urb(cardp->tx_urb); |
70 | usb_kill_urb(cardp->rx_urb); | 82 | usb_kill_urb(cardp->rx_urb); |
@@ -81,6 +93,8 @@ static void if_usb_free(struct if_usb_card *cardp) | |||
81 | 93 | ||
82 | kfree(cardp->ep_out_buf); | 94 | kfree(cardp->ep_out_buf); |
83 | cardp->ep_out_buf = NULL; | 95 | cardp->ep_out_buf = NULL; |
96 | |||
97 | lbtf_deb_leave(LBTF_DEB_USB); | ||
84 | } | 98 | } |
85 | 99 | ||
86 | static void if_usb_setup_firmware(struct lbtf_private *priv) | 100 | static void if_usb_setup_firmware(struct lbtf_private *priv) |
@@ -88,23 +102,33 @@ static void if_usb_setup_firmware(struct lbtf_private *priv) | |||
88 | struct if_usb_card *cardp = priv->card; | 102 | struct if_usb_card *cardp = priv->card; |
89 | struct cmd_ds_set_boot2_ver b2_cmd; | 103 | struct cmd_ds_set_boot2_ver b2_cmd; |
90 | 104 | ||
105 | lbtf_deb_enter(LBTF_DEB_USB); | ||
106 | |||
91 | if_usb_submit_rx_urb(cardp); | 107 | if_usb_submit_rx_urb(cardp); |
92 | b2_cmd.hdr.size = cpu_to_le16(sizeof(b2_cmd)); | 108 | b2_cmd.hdr.size = cpu_to_le16(sizeof(b2_cmd)); |
93 | b2_cmd.action = 0; | 109 | b2_cmd.action = 0; |
94 | b2_cmd.version = cardp->boot2_version; | 110 | b2_cmd.version = cardp->boot2_version; |
95 | 111 | ||
96 | if (lbtf_cmd_with_response(priv, CMD_SET_BOOT2_VER, &b2_cmd)) | 112 | if (lbtf_cmd_with_response(priv, CMD_SET_BOOT2_VER, &b2_cmd)) |
97 | printk(KERN_INFO "libertastf: setting boot2 version failed\n"); | 113 | lbtf_deb_usb("Setting boot2 version failed\n"); |
114 | |||
115 | lbtf_deb_leave(LBTF_DEB_USB); | ||
98 | } | 116 | } |
99 | 117 | ||
100 | static void if_usb_fw_timeo(unsigned long priv) | 118 | static void if_usb_fw_timeo(unsigned long priv) |
101 | { | 119 | { |
102 | struct if_usb_card *cardp = (void *)priv; | 120 | struct if_usb_card *cardp = (void *)priv; |
103 | 121 | ||
104 | if (!cardp->fwdnldover) | 122 | lbtf_deb_enter(LBTF_DEB_USB); |
123 | if (!cardp->fwdnldover) { | ||
105 | /* Download timed out */ | 124 | /* Download timed out */ |
106 | cardp->priv->surpriseremoved = 1; | 125 | cardp->priv->surpriseremoved = 1; |
126 | pr_err("Download timed out\n"); | ||
127 | } else { | ||
128 | lbtf_deb_usb("Download complete, no event. Assuming success\n"); | ||
129 | } | ||
107 | wake_up(&cardp->fw_wq); | 130 | wake_up(&cardp->fw_wq); |
131 | lbtf_deb_leave(LBTF_DEB_USB); | ||
108 | } | 132 | } |
109 | 133 | ||
110 | /** | 134 | /** |
@@ -125,11 +149,14 @@ static int if_usb_probe(struct usb_interface *intf, | |||
125 | struct if_usb_card *cardp; | 149 | struct if_usb_card *cardp; |
126 | int i; | 150 | int i; |
127 | 151 | ||
152 | lbtf_deb_enter(LBTF_DEB_USB); | ||
128 | udev = interface_to_usbdev(intf); | 153 | udev = interface_to_usbdev(intf); |
129 | 154 | ||
130 | cardp = kzalloc(sizeof(struct if_usb_card), GFP_KERNEL); | 155 | cardp = kzalloc(sizeof(struct if_usb_card), GFP_KERNEL); |
131 | if (!cardp) | 156 | if (!cardp) { |
157 | pr_err("Out of memory allocating private data.\n"); | ||
132 | goto error; | 158 | goto error; |
159 | } | ||
133 | 160 | ||
134 | setup_timer(&cardp->fw_timeout, if_usb_fw_timeo, (unsigned long)cardp); | 161 | setup_timer(&cardp->fw_timeout, if_usb_fw_timeo, (unsigned long)cardp); |
135 | init_waitqueue_head(&cardp->fw_wq); | 162 | init_waitqueue_head(&cardp->fw_wq); |
@@ -137,38 +164,62 @@ static int if_usb_probe(struct usb_interface *intf, | |||
137 | cardp->udev = udev; | 164 | cardp->udev = udev; |
138 | iface_desc = intf->cur_altsetting; | 165 | iface_desc = intf->cur_altsetting; |
139 | 166 | ||
167 | lbtf_deb_usbd(&udev->dev, "bcdUSB = 0x%X bDeviceClass = 0x%X" | ||
168 | " bDeviceSubClass = 0x%X, bDeviceProtocol = 0x%X\n", | ||
169 | le16_to_cpu(udev->descriptor.bcdUSB), | ||
170 | udev->descriptor.bDeviceClass, | ||
171 | udev->descriptor.bDeviceSubClass, | ||
172 | udev->descriptor.bDeviceProtocol); | ||
173 | |||
140 | for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) { | 174 | for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) { |
141 | endpoint = &iface_desc->endpoint[i].desc; | 175 | endpoint = &iface_desc->endpoint[i].desc; |
142 | if (usb_endpoint_is_bulk_in(endpoint)) { | 176 | if (usb_endpoint_is_bulk_in(endpoint)) { |
143 | cardp->ep_in_size = | 177 | cardp->ep_in_size = |
144 | le16_to_cpu(endpoint->wMaxPacketSize); | 178 | le16_to_cpu(endpoint->wMaxPacketSize); |
145 | cardp->ep_in = usb_endpoint_num(endpoint); | 179 | cardp->ep_in = usb_endpoint_num(endpoint); |
180 | |||
181 | lbtf_deb_usbd(&udev->dev, "in_endpoint = %d\n", cardp->ep_in); | ||
182 | lbtf_deb_usbd(&udev->dev, "Bulk in size is %d\n", cardp->ep_in_size); | ||
146 | } else if (usb_endpoint_is_bulk_out(endpoint)) { | 183 | } else if (usb_endpoint_is_bulk_out(endpoint)) { |
147 | cardp->ep_out_size = | 184 | cardp->ep_out_size = |
148 | le16_to_cpu(endpoint->wMaxPacketSize); | 185 | le16_to_cpu(endpoint->wMaxPacketSize); |
149 | cardp->ep_out = usb_endpoint_num(endpoint); | 186 | cardp->ep_out = usb_endpoint_num(endpoint); |
187 | |||
188 | lbtf_deb_usbd(&udev->dev, "out_endpoint = %d\n", cardp->ep_out); | ||
189 | lbtf_deb_usbd(&udev->dev, "Bulk out size is %d\n", | ||
190 | cardp->ep_out_size); | ||
150 | } | 191 | } |
151 | } | 192 | } |
152 | if (!cardp->ep_out_size || !cardp->ep_in_size) | 193 | if (!cardp->ep_out_size || !cardp->ep_in_size) { |
194 | lbtf_deb_usbd(&udev->dev, "Endpoints not found\n"); | ||
153 | /* Endpoints not found */ | 195 | /* Endpoints not found */ |
154 | goto dealloc; | 196 | goto dealloc; |
197 | } | ||
155 | 198 | ||
156 | cardp->rx_urb = usb_alloc_urb(0, GFP_KERNEL); | 199 | cardp->rx_urb = usb_alloc_urb(0, GFP_KERNEL); |
157 | if (!cardp->rx_urb) | 200 | if (!cardp->rx_urb) { |
201 | lbtf_deb_usbd(&udev->dev, "Rx URB allocation failed\n"); | ||
158 | goto dealloc; | 202 | goto dealloc; |
203 | } | ||
159 | 204 | ||
160 | cardp->tx_urb = usb_alloc_urb(0, GFP_KERNEL); | 205 | cardp->tx_urb = usb_alloc_urb(0, GFP_KERNEL); |
161 | if (!cardp->tx_urb) | 206 | if (!cardp->tx_urb) { |
207 | lbtf_deb_usbd(&udev->dev, "Tx URB allocation failed\n"); | ||
162 | goto dealloc; | 208 | goto dealloc; |
209 | } | ||
163 | 210 | ||
164 | cardp->cmd_urb = usb_alloc_urb(0, GFP_KERNEL); | 211 | cardp->cmd_urb = usb_alloc_urb(0, GFP_KERNEL); |
165 | if (!cardp->cmd_urb) | 212 | if (!cardp->cmd_urb) { |
213 | lbtf_deb_usbd(&udev->dev, "Cmd URB allocation failed\n"); | ||
166 | goto dealloc; | 214 | goto dealloc; |
215 | } | ||
167 | 216 | ||
168 | cardp->ep_out_buf = kmalloc(MRVDRV_ETH_TX_PACKET_BUFFER_SIZE, | 217 | cardp->ep_out_buf = kmalloc(MRVDRV_ETH_TX_PACKET_BUFFER_SIZE, |
169 | GFP_KERNEL); | 218 | GFP_KERNEL); |
170 | if (!cardp->ep_out_buf) | 219 | if (!cardp->ep_out_buf) { |
220 | lbtf_deb_usbd(&udev->dev, "Could not allocate buffer\n"); | ||
171 | goto dealloc; | 221 | goto dealloc; |
222 | } | ||
172 | 223 | ||
173 | priv = lbtf_add_card(cardp, &udev->dev); | 224 | priv = lbtf_add_card(cardp, &udev->dev); |
174 | if (!priv) | 225 | if (!priv) |
@@ -189,6 +240,7 @@ static int if_usb_probe(struct usb_interface *intf, | |||
189 | dealloc: | 240 | dealloc: |
190 | if_usb_free(cardp); | 241 | if_usb_free(cardp); |
191 | error: | 242 | error: |
243 | lbtf_deb_leave(LBTF_DEB_MAIN); | ||
192 | return -ENOMEM; | 244 | return -ENOMEM; |
193 | } | 245 | } |
194 | 246 | ||
@@ -202,6 +254,8 @@ static void if_usb_disconnect(struct usb_interface *intf) | |||
202 | struct if_usb_card *cardp = usb_get_intfdata(intf); | 254 | struct if_usb_card *cardp = usb_get_intfdata(intf); |
203 | struct lbtf_private *priv = (struct lbtf_private *) cardp->priv; | 255 | struct lbtf_private *priv = (struct lbtf_private *) cardp->priv; |
204 | 256 | ||
257 | lbtf_deb_enter(LBTF_DEB_MAIN); | ||
258 | |||
205 | if_usb_reset_device(cardp); | 259 | if_usb_reset_device(cardp); |
206 | 260 | ||
207 | if (priv) | 261 | if (priv) |
@@ -212,6 +266,8 @@ static void if_usb_disconnect(struct usb_interface *intf) | |||
212 | 266 | ||
213 | usb_set_intfdata(intf, NULL); | 267 | usb_set_intfdata(intf, NULL); |
214 | usb_put_dev(interface_to_usbdev(intf)); | 268 | usb_put_dev(interface_to_usbdev(intf)); |
269 | |||
270 | lbtf_deb_leave(LBTF_DEB_MAIN); | ||
215 | } | 271 | } |
216 | 272 | ||
217 | /** | 273 | /** |
@@ -226,6 +282,8 @@ static int if_usb_send_fw_pkt(struct if_usb_card *cardp) | |||
226 | struct fwdata *fwdata = cardp->ep_out_buf; | 282 | struct fwdata *fwdata = cardp->ep_out_buf; |
227 | u8 *firmware = (u8 *) cardp->fw->data; | 283 | u8 *firmware = (u8 *) cardp->fw->data; |
228 | 284 | ||
285 | lbtf_deb_enter(LBTF_DEB_FW); | ||
286 | |||
229 | /* If we got a CRC failure on the last block, back | 287 | /* If we got a CRC failure on the last block, back |
230 | up and retry it */ | 288 | up and retry it */ |
231 | if (!cardp->CRC_OK) { | 289 | if (!cardp->CRC_OK) { |
@@ -233,6 +291,9 @@ static int if_usb_send_fw_pkt(struct if_usb_card *cardp) | |||
233 | cardp->fwseqnum--; | 291 | cardp->fwseqnum--; |
234 | } | 292 | } |
235 | 293 | ||
294 | lbtf_deb_usb2(&cardp->udev->dev, "totalbytes = %d\n", | ||
295 | cardp->totalbytes); | ||
296 | |||
236 | /* struct fwdata (which we sent to the card) has an | 297 | /* struct fwdata (which we sent to the card) has an |
237 | extra __le32 field in between the header and the data, | 298 | extra __le32 field in between the header and the data, |
238 | which is not in the struct fwheader in the actual | 299 | which is not in the struct fwheader in the actual |
@@ -246,18 +307,33 @@ static int if_usb_send_fw_pkt(struct if_usb_card *cardp) | |||
246 | memcpy(fwdata->data, &firmware[cardp->totalbytes], | 307 | memcpy(fwdata->data, &firmware[cardp->totalbytes], |
247 | le32_to_cpu(fwdata->hdr.datalength)); | 308 | le32_to_cpu(fwdata->hdr.datalength)); |
248 | 309 | ||
310 | lbtf_deb_usb2(&cardp->udev->dev, "Data length = %d\n", | ||
311 | le32_to_cpu(fwdata->hdr.datalength)); | ||
312 | |||
249 | fwdata->seqnum = cpu_to_le32(++cardp->fwseqnum); | 313 | fwdata->seqnum = cpu_to_le32(++cardp->fwseqnum); |
250 | cardp->totalbytes += le32_to_cpu(fwdata->hdr.datalength); | 314 | cardp->totalbytes += le32_to_cpu(fwdata->hdr.datalength); |
251 | 315 | ||
252 | usb_tx_block(cardp, cardp->ep_out_buf, sizeof(struct fwdata) + | 316 | usb_tx_block(cardp, cardp->ep_out_buf, sizeof(struct fwdata) + |
253 | le32_to_cpu(fwdata->hdr.datalength), 0); | 317 | le32_to_cpu(fwdata->hdr.datalength), 0); |
254 | 318 | ||
255 | if (fwdata->hdr.dnldcmd == cpu_to_le32(FW_HAS_LAST_BLOCK)) | 319 | if (fwdata->hdr.dnldcmd == cpu_to_le32(FW_HAS_DATA_TO_RECV)) { |
320 | lbtf_deb_usb2(&cardp->udev->dev, "There are data to follow\n"); | ||
321 | lbtf_deb_usb2(&cardp->udev->dev, "seqnum = %d totalbytes = %d\n", | ||
322 | cardp->fwseqnum, cardp->totalbytes); | ||
323 | } else if (fwdata->hdr.dnldcmd == cpu_to_le32(FW_HAS_LAST_BLOCK)) { | ||
324 | lbtf_deb_usb2(&cardp->udev->dev, "Host has finished FW downloading\n"); | ||
325 | lbtf_deb_usb2(&cardp->udev->dev, "Donwloading FW JUMP BLOCK\n"); | ||
326 | |||
256 | /* Host has finished FW downloading | 327 | /* Host has finished FW downloading |
257 | * Donwloading FW JUMP BLOCK | 328 | * Donwloading FW JUMP BLOCK |
258 | */ | 329 | */ |
259 | cardp->fwfinalblk = 1; | 330 | cardp->fwfinalblk = 1; |
331 | } | ||
260 | 332 | ||
333 | lbtf_deb_usb2(&cardp->udev->dev, "Firmware download done; size %d\n", | ||
334 | cardp->totalbytes); | ||
335 | |||
336 | lbtf_deb_leave(LBTF_DEB_FW); | ||
261 | return 0; | 337 | return 0; |
262 | } | 338 | } |
263 | 339 | ||
@@ -266,6 +342,8 @@ static int if_usb_reset_device(struct if_usb_card *cardp) | |||
266 | struct cmd_ds_802_11_reset *cmd = cardp->ep_out_buf + 4; | 342 | struct cmd_ds_802_11_reset *cmd = cardp->ep_out_buf + 4; |
267 | int ret; | 343 | int ret; |
268 | 344 | ||
345 | lbtf_deb_enter(LBTF_DEB_USB); | ||
346 | |||
269 | *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_REQUEST); | 347 | *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_REQUEST); |
270 | 348 | ||
271 | cmd->hdr.command = cpu_to_le16(CMD_802_11_RESET); | 349 | cmd->hdr.command = cpu_to_le16(CMD_802_11_RESET); |
@@ -280,6 +358,8 @@ static int if_usb_reset_device(struct if_usb_card *cardp) | |||
280 | ret = usb_reset_device(cardp->udev); | 358 | ret = usb_reset_device(cardp->udev); |
281 | msleep(100); | 359 | msleep(100); |
282 | 360 | ||
361 | lbtf_deb_leave_args(LBTF_DEB_USB, "ret %d", ret); | ||
362 | |||
283 | return ret; | 363 | return ret; |
284 | } | 364 | } |
285 | EXPORT_SYMBOL_GPL(if_usb_reset_device); | 365 | EXPORT_SYMBOL_GPL(if_usb_reset_device); |
@@ -297,11 +377,15 @@ EXPORT_SYMBOL_GPL(if_usb_reset_device); | |||
297 | static int usb_tx_block(struct if_usb_card *cardp, uint8_t *payload, | 377 | static int usb_tx_block(struct if_usb_card *cardp, uint8_t *payload, |
298 | uint16_t nb, u8 data) | 378 | uint16_t nb, u8 data) |
299 | { | 379 | { |
380 | int ret = -1; | ||
300 | struct urb *urb; | 381 | struct urb *urb; |
301 | 382 | ||
383 | lbtf_deb_enter(LBTF_DEB_USB); | ||
302 | /* check if device is removed */ | 384 | /* check if device is removed */ |
303 | if (cardp->priv->surpriseremoved) | 385 | if (cardp->priv->surpriseremoved) { |
304 | return -1; | 386 | lbtf_deb_usbd(&cardp->udev->dev, "Device removed\n"); |
387 | goto tx_ret; | ||
388 | } | ||
305 | 389 | ||
306 | if (data) | 390 | if (data) |
307 | urb = cardp->tx_urb; | 391 | urb = cardp->tx_urb; |
@@ -315,19 +399,34 @@ static int usb_tx_block(struct if_usb_card *cardp, uint8_t *payload, | |||
315 | 399 | ||
316 | urb->transfer_flags |= URB_ZERO_PACKET; | 400 | urb->transfer_flags |= URB_ZERO_PACKET; |
317 | 401 | ||
318 | if (usb_submit_urb(urb, GFP_ATOMIC)) | 402 | if (usb_submit_urb(urb, GFP_ATOMIC)) { |
319 | return -1; | 403 | lbtf_deb_usbd(&cardp->udev->dev, "usb_submit_urb failed: %d\n", ret); |
320 | return 0; | 404 | goto tx_ret; |
405 | } | ||
406 | |||
407 | lbtf_deb_usb2(&cardp->udev->dev, "usb_submit_urb success\n"); | ||
408 | |||
409 | ret = 0; | ||
410 | |||
411 | tx_ret: | ||
412 | lbtf_deb_leave(LBTF_DEB_USB); | ||
413 | return ret; | ||
321 | } | 414 | } |
322 | 415 | ||
323 | static int __if_usb_submit_rx_urb(struct if_usb_card *cardp, | 416 | static int __if_usb_submit_rx_urb(struct if_usb_card *cardp, |
324 | void (*callbackfn)(struct urb *urb)) | 417 | void (*callbackfn)(struct urb *urb)) |
325 | { | 418 | { |
326 | struct sk_buff *skb; | 419 | struct sk_buff *skb; |
420 | int ret = -1; | ||
421 | |||
422 | lbtf_deb_enter(LBTF_DEB_USB); | ||
327 | 423 | ||
328 | skb = dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE); | 424 | skb = dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE); |
329 | if (!skb) | 425 | if (!skb) { |
426 | pr_err("No free skb\n"); | ||
427 | lbtf_deb_leave(LBTF_DEB_USB); | ||
330 | return -1; | 428 | return -1; |
429 | } | ||
331 | 430 | ||
332 | cardp->rx_skb = skb; | 431 | cardp->rx_skb = skb; |
333 | 432 | ||
@@ -339,12 +438,19 @@ static int __if_usb_submit_rx_urb(struct if_usb_card *cardp, | |||
339 | 438 | ||
340 | cardp->rx_urb->transfer_flags |= URB_ZERO_PACKET; | 439 | cardp->rx_urb->transfer_flags |= URB_ZERO_PACKET; |
341 | 440 | ||
342 | if (usb_submit_urb(cardp->rx_urb, GFP_ATOMIC)) { | 441 | lbtf_deb_usb2(&cardp->udev->dev, "Pointer for rx_urb %p\n", cardp->rx_urb); |
442 | ret = usb_submit_urb(cardp->rx_urb, GFP_ATOMIC); | ||
443 | if (ret) { | ||
444 | lbtf_deb_usbd(&cardp->udev->dev, "Submit Rx URB failed: %d\n", ret); | ||
343 | kfree_skb(skb); | 445 | kfree_skb(skb); |
344 | cardp->rx_skb = NULL; | 446 | cardp->rx_skb = NULL; |
447 | lbtf_deb_leave(LBTF_DEB_USB); | ||
345 | return -1; | 448 | return -1; |
346 | } else | 449 | } else { |
450 | lbtf_deb_usb2(&cardp->udev->dev, "Submit Rx URB success\n"); | ||
451 | lbtf_deb_leave(LBTF_DEB_USB); | ||
347 | return 0; | 452 | return 0; |
453 | } | ||
348 | } | 454 | } |
349 | 455 | ||
350 | static int if_usb_submit_rx_urb_fwload(struct if_usb_card *cardp) | 456 | static int if_usb_submit_rx_urb_fwload(struct if_usb_card *cardp) |
@@ -364,8 +470,12 @@ static void if_usb_receive_fwload(struct urb *urb) | |||
364 | struct fwsyncheader *syncfwheader; | 470 | struct fwsyncheader *syncfwheader; |
365 | struct bootcmdresp bcmdresp; | 471 | struct bootcmdresp bcmdresp; |
366 | 472 | ||
473 | lbtf_deb_enter(LBTF_DEB_USB); | ||
367 | if (urb->status) { | 474 | if (urb->status) { |
475 | lbtf_deb_usbd(&cardp->udev->dev, | ||
476 | "URB status is failed during fw load\n"); | ||
368 | kfree_skb(skb); | 477 | kfree_skb(skb); |
478 | lbtf_deb_leave(LBTF_DEB_USB); | ||
369 | return; | 479 | return; |
370 | } | 480 | } |
371 | 481 | ||
@@ -373,12 +483,17 @@ static void if_usb_receive_fwload(struct urb *urb) | |||
373 | __le32 *tmp = (__le32 *)(skb->data); | 483 | __le32 *tmp = (__le32 *)(skb->data); |
374 | 484 | ||
375 | if (tmp[0] == cpu_to_le32(CMD_TYPE_INDICATION) && | 485 | if (tmp[0] == cpu_to_le32(CMD_TYPE_INDICATION) && |
376 | tmp[1] == cpu_to_le32(MACREG_INT_CODE_FIRMWARE_READY)) | 486 | tmp[1] == cpu_to_le32(MACREG_INT_CODE_FIRMWARE_READY)) { |
377 | /* Firmware ready event received */ | 487 | /* Firmware ready event received */ |
488 | pr_info("Firmware ready event received\n"); | ||
378 | wake_up(&cardp->fw_wq); | 489 | wake_up(&cardp->fw_wq); |
379 | else | 490 | } else { |
491 | lbtf_deb_usb("Waiting for confirmation; got %x %x\n", | ||
492 | le32_to_cpu(tmp[0]), le32_to_cpu(tmp[1])); | ||
380 | if_usb_submit_rx_urb_fwload(cardp); | 493 | if_usb_submit_rx_urb_fwload(cardp); |
494 | } | ||
381 | kfree_skb(skb); | 495 | kfree_skb(skb); |
496 | lbtf_deb_leave(LBTF_DEB_USB); | ||
382 | return; | 497 | return; |
383 | } | 498 | } |
384 | if (cardp->bootcmdresp <= 0) { | 499 | if (cardp->bootcmdresp <= 0) { |
@@ -389,34 +504,60 @@ static void if_usb_receive_fwload(struct urb *urb) | |||
389 | if_usb_submit_rx_urb_fwload(cardp); | 504 | if_usb_submit_rx_urb_fwload(cardp); |
390 | cardp->bootcmdresp = 1; | 505 | cardp->bootcmdresp = 1; |
391 | /* Received valid boot command response */ | 506 | /* Received valid boot command response */ |
507 | lbtf_deb_usbd(&cardp->udev->dev, | ||
508 | "Received valid boot command response\n"); | ||
509 | lbtf_deb_leave(LBTF_DEB_USB); | ||
392 | return; | 510 | return; |
393 | } | 511 | } |
394 | if (bcmdresp.magic != cpu_to_le32(BOOT_CMD_MAGIC_NUMBER)) { | 512 | if (bcmdresp.magic != cpu_to_le32(BOOT_CMD_MAGIC_NUMBER)) { |
395 | if (bcmdresp.magic == cpu_to_le32(CMD_TYPE_REQUEST) || | 513 | if (bcmdresp.magic == cpu_to_le32(CMD_TYPE_REQUEST) || |
396 | bcmdresp.magic == cpu_to_le32(CMD_TYPE_DATA) || | 514 | bcmdresp.magic == cpu_to_le32(CMD_TYPE_DATA) || |
397 | bcmdresp.magic == cpu_to_le32(CMD_TYPE_INDICATION)) | 515 | bcmdresp.magic == cpu_to_le32(CMD_TYPE_INDICATION)) { |
516 | if (!cardp->bootcmdresp) | ||
517 | pr_info("Firmware already seems alive; resetting\n"); | ||
398 | cardp->bootcmdresp = -1; | 518 | cardp->bootcmdresp = -1; |
399 | } else if (bcmdresp.cmd == BOOT_CMD_FW_BY_USB && | 519 | } else { |
400 | bcmdresp.result == BOOT_CMD_RESP_OK) | 520 | pr_info("boot cmd response wrong magic number (0x%x)\n", |
521 | le32_to_cpu(bcmdresp.magic)); | ||
522 | } | ||
523 | } else if (bcmdresp.cmd != BOOT_CMD_FW_BY_USB) { | ||
524 | pr_info("boot cmd response cmd_tag error (%d)\n", | ||
525 | bcmdresp.cmd); | ||
526 | } else if (bcmdresp.result != BOOT_CMD_RESP_OK) { | ||
527 | pr_info("boot cmd response result error (%d)\n", | ||
528 | bcmdresp.result); | ||
529 | } else { | ||
401 | cardp->bootcmdresp = 1; | 530 | cardp->bootcmdresp = 1; |
531 | lbtf_deb_usbd(&cardp->udev->dev, | ||
532 | "Received valid boot command response\n"); | ||
533 | } | ||
402 | 534 | ||
403 | kfree_skb(skb); | 535 | kfree_skb(skb); |
404 | if_usb_submit_rx_urb_fwload(cardp); | 536 | if_usb_submit_rx_urb_fwload(cardp); |
537 | lbtf_deb_leave(LBTF_DEB_USB); | ||
405 | return; | 538 | return; |
406 | } | 539 | } |
407 | 540 | ||
408 | syncfwheader = kmalloc(sizeof(struct fwsyncheader), GFP_ATOMIC); | 541 | syncfwheader = kmalloc(sizeof(struct fwsyncheader), GFP_ATOMIC); |
409 | if (!syncfwheader) { | 542 | if (!syncfwheader) { |
543 | lbtf_deb_usbd(&cardp->udev->dev, "Failure to allocate syncfwheader\n"); | ||
410 | kfree_skb(skb); | 544 | kfree_skb(skb); |
545 | lbtf_deb_leave(LBTF_DEB_USB); | ||
411 | return; | 546 | return; |
412 | } | 547 | } |
413 | 548 | ||
414 | memcpy(syncfwheader, skb->data, sizeof(struct fwsyncheader)); | 549 | memcpy(syncfwheader, skb->data, sizeof(struct fwsyncheader)); |
415 | 550 | ||
416 | if (!syncfwheader->cmd) | 551 | if (!syncfwheader->cmd) { |
552 | lbtf_deb_usb2(&cardp->udev->dev, "FW received Blk with correct CRC\n"); | ||
553 | lbtf_deb_usb2(&cardp->udev->dev, "FW received Blk seqnum = %d\n", | ||
554 | le32_to_cpu(syncfwheader->seqnum)); | ||
417 | cardp->CRC_OK = 1; | 555 | cardp->CRC_OK = 1; |
418 | else | 556 | } else { |
557 | lbtf_deb_usbd(&cardp->udev->dev, "FW received Blk with CRC error\n"); | ||
419 | cardp->CRC_OK = 0; | 558 | cardp->CRC_OK = 0; |
559 | } | ||
560 | |||
420 | kfree_skb(skb); | 561 | kfree_skb(skb); |
421 | 562 | ||
422 | /* reschedule timer for 200ms hence */ | 563 | /* reschedule timer for 200ms hence */ |
@@ -434,7 +575,7 @@ static void if_usb_receive_fwload(struct urb *urb) | |||
434 | 575 | ||
435 | kfree(syncfwheader); | 576 | kfree(syncfwheader); |
436 | 577 | ||
437 | return; | 578 | lbtf_deb_leave(LBTF_DEB_USB); |
438 | } | 579 | } |
439 | 580 | ||
440 | #define MRVDRV_MIN_PKT_LEN 30 | 581 | #define MRVDRV_MIN_PKT_LEN 30 |
@@ -445,6 +586,7 @@ static inline void process_cmdtypedata(int recvlength, struct sk_buff *skb, | |||
445 | { | 586 | { |
446 | if (recvlength > MRVDRV_ETH_RX_PACKET_BUFFER_SIZE + MESSAGE_HEADER_LEN | 587 | if (recvlength > MRVDRV_ETH_RX_PACKET_BUFFER_SIZE + MESSAGE_HEADER_LEN |
447 | || recvlength < MRVDRV_MIN_PKT_LEN) { | 588 | || recvlength < MRVDRV_MIN_PKT_LEN) { |
589 | lbtf_deb_usbd(&cardp->udev->dev, "Packet length is Invalid\n"); | ||
448 | kfree_skb(skb); | 590 | kfree_skb(skb); |
449 | return; | 591 | return; |
450 | } | 592 | } |
@@ -460,6 +602,8 @@ static inline void process_cmdrequest(int recvlength, uint8_t *recvbuff, | |||
460 | struct lbtf_private *priv) | 602 | struct lbtf_private *priv) |
461 | { | 603 | { |
462 | if (recvlength > LBS_CMD_BUFFER_SIZE) { | 604 | if (recvlength > LBS_CMD_BUFFER_SIZE) { |
605 | lbtf_deb_usbd(&cardp->udev->dev, | ||
606 | "The receive buffer is too large\n"); | ||
463 | kfree_skb(skb); | 607 | kfree_skb(skb); |
464 | return; | 608 | return; |
465 | } | 609 | } |
@@ -489,16 +633,24 @@ static void if_usb_receive(struct urb *urb) | |||
489 | uint32_t recvtype = 0; | 633 | uint32_t recvtype = 0; |
490 | __le32 *pkt = (__le32 *) skb->data; | 634 | __le32 *pkt = (__le32 *) skb->data; |
491 | 635 | ||
636 | lbtf_deb_enter(LBTF_DEB_USB); | ||
637 | |||
492 | if (recvlength) { | 638 | if (recvlength) { |
493 | if (urb->status) { | 639 | if (urb->status) { |
640 | lbtf_deb_usbd(&cardp->udev->dev, "RX URB failed: %d\n", | ||
641 | urb->status); | ||
494 | kfree_skb(skb); | 642 | kfree_skb(skb); |
495 | goto setup_for_next; | 643 | goto setup_for_next; |
496 | } | 644 | } |
497 | 645 | ||
498 | recvbuff = skb->data; | 646 | recvbuff = skb->data; |
499 | recvtype = le32_to_cpu(pkt[0]); | 647 | recvtype = le32_to_cpu(pkt[0]); |
648 | lbtf_deb_usbd(&cardp->udev->dev, | ||
649 | "Recv length = 0x%x, Recv type = 0x%X\n", | ||
650 | recvlength, recvtype); | ||
500 | } else if (urb->status) { | 651 | } else if (urb->status) { |
501 | kfree_skb(skb); | 652 | kfree_skb(skb); |
653 | lbtf_deb_leave(LBTF_DEB_USB); | ||
502 | return; | 654 | return; |
503 | } | 655 | } |
504 | 656 | ||
@@ -515,6 +667,7 @@ static void if_usb_receive(struct urb *urb) | |||
515 | { | 667 | { |
516 | /* Event cause handling */ | 668 | /* Event cause handling */ |
517 | u32 event_cause = le32_to_cpu(pkt[1]); | 669 | u32 event_cause = le32_to_cpu(pkt[1]); |
670 | lbtf_deb_usbd(&cardp->udev->dev, "**EVENT** 0x%X\n", event_cause); | ||
518 | 671 | ||
519 | /* Icky undocumented magic special case */ | 672 | /* Icky undocumented magic special case */ |
520 | if (event_cause & 0xffff0000) { | 673 | if (event_cause & 0xffff0000) { |
@@ -529,21 +682,22 @@ static void if_usb_receive(struct urb *urb) | |||
529 | } else if (event_cause == LBTF_EVENT_BCN_SENT) | 682 | } else if (event_cause == LBTF_EVENT_BCN_SENT) |
530 | lbtf_bcn_sent(priv); | 683 | lbtf_bcn_sent(priv); |
531 | else | 684 | else |
532 | printk(KERN_DEBUG | 685 | lbtf_deb_usbd(&cardp->udev->dev, |
533 | "Unsupported notification %d received\n", | 686 | "Unsupported notification %d received\n", |
534 | event_cause); | 687 | event_cause); |
535 | kfree_skb(skb); | 688 | kfree_skb(skb); |
536 | break; | 689 | break; |
537 | } | 690 | } |
538 | default: | 691 | default: |
539 | printk(KERN_DEBUG "libertastf: unknown command type 0x%X\n", | 692 | lbtf_deb_usbd(&cardp->udev->dev, |
540 | recvtype); | 693 | "libertastf: unknown command type 0x%X\n", recvtype); |
541 | kfree_skb(skb); | 694 | kfree_skb(skb); |
542 | break; | 695 | break; |
543 | } | 696 | } |
544 | 697 | ||
545 | setup_for_next: | 698 | setup_for_next: |
546 | if_usb_submit_rx_urb(cardp); | 699 | if_usb_submit_rx_urb(cardp); |
700 | lbtf_deb_leave(LBTF_DEB_USB); | ||
547 | } | 701 | } |
548 | 702 | ||
549 | /** | 703 | /** |
@@ -562,6 +716,9 @@ static int if_usb_host_to_card(struct lbtf_private *priv, uint8_t type, | |||
562 | struct if_usb_card *cardp = priv->card; | 716 | struct if_usb_card *cardp = priv->card; |
563 | u8 data = 0; | 717 | u8 data = 0; |
564 | 718 | ||
719 | lbtf_deb_usbd(&cardp->udev->dev, "*** type = %u\n", type); | ||
720 | lbtf_deb_usbd(&cardp->udev->dev, "size after = %d\n", nb); | ||
721 | |||
565 | if (type == MVMS_CMD) { | 722 | if (type == MVMS_CMD) { |
566 | *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_REQUEST); | 723 | *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_REQUEST); |
567 | } else { | 724 | } else { |
@@ -639,8 +796,10 @@ static int check_fwfile_format(const u8 *data, u32 totlen) | |||
639 | } while (!exit); | 796 | } while (!exit); |
640 | 797 | ||
641 | if (ret) | 798 | if (ret) |
642 | printk(KERN_INFO | 799 | pr_err("firmware file format check FAIL\n"); |
643 | "libertastf: firmware file format check failed\n"); | 800 | else |
801 | lbtf_deb_fw("firmware file format check PASS\n"); | ||
802 | |||
644 | return ret; | 803 | return ret; |
645 | } | 804 | } |
646 | 805 | ||
@@ -651,10 +810,12 @@ static int if_usb_prog_firmware(struct if_usb_card *cardp) | |||
651 | static int reset_count = 10; | 810 | static int reset_count = 10; |
652 | int ret = 0; | 811 | int ret = 0; |
653 | 812 | ||
813 | lbtf_deb_enter(LBTF_DEB_USB); | ||
814 | |||
654 | ret = request_firmware(&cardp->fw, lbtf_fw_name, &cardp->udev->dev); | 815 | ret = request_firmware(&cardp->fw, lbtf_fw_name, &cardp->udev->dev); |
655 | if (ret < 0) { | 816 | if (ret < 0) { |
656 | printk(KERN_INFO "libertastf: firmware %s not found\n", | 817 | pr_err("request_firmware() failed with %#x\n", ret); |
657 | lbtf_fw_name); | 818 | pr_err("firmware %s not found\n", lbtf_fw_name); |
658 | goto done; | 819 | goto done; |
659 | } | 820 | } |
660 | 821 | ||
@@ -663,6 +824,7 @@ static int if_usb_prog_firmware(struct if_usb_card *cardp) | |||
663 | 824 | ||
664 | restart: | 825 | restart: |
665 | if (if_usb_submit_rx_urb_fwload(cardp) < 0) { | 826 | if (if_usb_submit_rx_urb_fwload(cardp) < 0) { |
827 | lbtf_deb_usbd(&cardp->udev->dev, "URB submission is failed\n"); | ||
666 | ret = -1; | 828 | ret = -1; |
667 | goto release_fw; | 829 | goto release_fw; |
668 | } | 830 | } |
@@ -709,14 +871,13 @@ restart: | |||
709 | usb_kill_urb(cardp->rx_urb); | 871 | usb_kill_urb(cardp->rx_urb); |
710 | 872 | ||
711 | if (!cardp->fwdnldover) { | 873 | if (!cardp->fwdnldover) { |
712 | printk(KERN_INFO "libertastf: failed to load fw," | 874 | pr_info("failed to load fw, resetting device!\n"); |
713 | " resetting device!\n"); | ||
714 | if (--reset_count >= 0) { | 875 | if (--reset_count >= 0) { |
715 | if_usb_reset_device(cardp); | 876 | if_usb_reset_device(cardp); |
716 | goto restart; | 877 | goto restart; |
717 | } | 878 | } |
718 | 879 | ||
719 | printk(KERN_INFO "libertastf: fw download failure\n"); | 880 | pr_info("FW download failure, time = %d ms\n", i * 100); |
720 | ret = -1; | 881 | ret = -1; |
721 | goto release_fw; | 882 | goto release_fw; |
722 | } | 883 | } |
@@ -730,6 +891,7 @@ restart: | |||
730 | if_usb_setup_firmware(cardp->priv); | 891 | if_usb_setup_firmware(cardp->priv); |
731 | 892 | ||
732 | done: | 893 | done: |
894 | lbtf_deb_leave_args(LBTF_DEB_USB, "ret %d", ret); | ||
733 | return ret; | 895 | return ret; |
734 | } | 896 | } |
735 | EXPORT_SYMBOL_GPL(if_usb_prog_firmware); | 897 | EXPORT_SYMBOL_GPL(if_usb_prog_firmware); |
@@ -751,13 +913,19 @@ static int __init if_usb_init_module(void) | |||
751 | { | 913 | { |
752 | int ret = 0; | 914 | int ret = 0; |
753 | 915 | ||
916 | lbtf_deb_enter(LBTF_DEB_MAIN); | ||
917 | |||
754 | ret = usb_register(&if_usb_driver); | 918 | ret = usb_register(&if_usb_driver); |
919 | |||
920 | lbtf_deb_leave_args(LBTF_DEB_MAIN, "ret %d", ret); | ||
755 | return ret; | 921 | return ret; |
756 | } | 922 | } |
757 | 923 | ||
758 | static void __exit if_usb_exit_module(void) | 924 | static void __exit if_usb_exit_module(void) |
759 | { | 925 | { |
926 | lbtf_deb_enter(LBTF_DEB_MAIN); | ||
760 | usb_deregister(&if_usb_driver); | 927 | usb_deregister(&if_usb_driver); |
928 | lbtf_deb_leave(LBTF_DEB_MAIN); | ||
761 | } | 929 | } |
762 | 930 | ||
763 | module_init(if_usb_init_module); | 931 | module_init(if_usb_init_module); |