Merge branch 'stacktrace-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[linux-2.6] / drivers / net / wimax / i2400m / usb-fw.c
1 /*
2  * Intel Wireless WiMAX Connection 2400m
3  * Firmware uploader's USB specifics
4  *
5  *
6  * Copyright (C) 2007-2008 Intel Corporation. All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  *   * Redistributions of source code must retain the above copyright
13  *     notice, this list of conditions and the following disclaimer.
14  *   * Redistributions in binary form must reproduce the above copyright
15  *     notice, this list of conditions and the following disclaimer in
16  *     the documentation and/or other materials provided with the
17  *     distribution.
18  *   * Neither the name of Intel Corporation nor the names of its
19  *     contributors may be used to endorse or promote products derived
20  *     from this software without specific prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
25  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
26  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
27  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
28  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
32  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33  *
34  *
35  * Intel Corporation <linux-wimax@intel.com>
36  * Yanir Lubetkin <yanirx.lubetkin@intel.com>
37  * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
38  *  - Initial implementation
39  *
40  * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
41  *  - bus generic/specific split
42  *
43  * THE PROCEDURE
44  *
45  * See fw.c for the generic description of this procedure.
46  *
47  * This file implements only the USB specifics. It boils down to how
48  * to send a command and waiting for an acknowledgement from the
49  * device.
50  *
51  * This code (and process) is single threaded. It assumes it is the
52  * only thread poking around (guaranteed by fw.c).
53  *
54  * COMMAND EXECUTION
55  *
56  * A write URB is posted with the buffer to the bulk output endpoint.
57  *
58  * ACK RECEPTION
59  *
60  * We just post a URB to the notification endpoint and wait for
61  * data. We repeat until we get all the data we expect (as indicated
62  * by the call from the bus generic code).
63  *
64  * The data is not read from the bulk in endpoint for boot mode.
65  *
66  * ROADMAP
67  *
68  * i2400mu_bus_bm_cmd_send
69  *   i2400m_bm_cmd_prepare...
70  *   i2400mu_tx_bulk_out
71  *
72  * i2400mu_bus_bm_wait_for_ack
73  *   i2400m_notif_submit
74  */
75 #include <linux/usb.h>
76 #include "i2400m-usb.h"
77
78
79 #define D_SUBMODULE fw
80 #include "usb-debug-levels.h"
81
82
83 /*
84  * Synchronous write to the device
85  *
86  * Takes care of updating EDC counts and thus, handle device errors.
87  */
88 static
89 ssize_t i2400mu_tx_bulk_out(struct i2400mu *i2400mu, void *buf, size_t buf_size)
90 {
91         int result;
92         struct device *dev = &i2400mu->usb_iface->dev;
93         int len;
94         struct usb_endpoint_descriptor *epd;
95         int pipe, do_autopm = 1;
96
97         result = usb_autopm_get_interface(i2400mu->usb_iface);
98         if (result < 0) {
99                 dev_err(dev, "BM-CMD: can't get autopm: %d\n", result);
100                 do_autopm = 0;
101         }
102         epd = usb_get_epd(i2400mu->usb_iface, I2400MU_EP_BULK_OUT);
103         pipe = usb_sndbulkpipe(i2400mu->usb_dev, epd->bEndpointAddress);
104 retry:
105         result = usb_bulk_msg(i2400mu->usb_dev, pipe, buf, buf_size, &len, HZ);
106         switch (result) {
107         case 0:
108                 if (len != buf_size) {
109                         dev_err(dev, "BM-CMD: short write (%u B vs %zu "
110                                 "expected)\n", len, buf_size);
111                         result = -EIO;
112                         break;
113                 }
114                 result = len;
115                 break;
116         case -EINVAL:                   /* while removing driver */
117         case -ENODEV:                   /* dev disconnect ... */
118         case -ENOENT:                   /* just ignore it */
119         case -ESHUTDOWN:                /* and exit */
120         case -ECONNRESET:
121                 result = -ESHUTDOWN;
122                 break;
123         case -ETIMEDOUT:                        /* bah... */
124                 break;
125         default:                                /* any other? */
126                 if (edc_inc(&i2400mu->urb_edc,
127                             EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) {
128                                 dev_err(dev, "BM-CMD: maximum errors in "
129                                         "URB exceeded; resetting device\n");
130                                 usb_queue_reset_device(i2400mu->usb_iface);
131                                 result = -ENODEV;
132                                 break;
133                 }
134                 dev_err(dev, "BM-CMD: URB error %d, retrying\n",
135                         result);
136                 goto retry;
137         }
138         result = len;
139         if (do_autopm)
140                 usb_autopm_put_interface(i2400mu->usb_iface);
141         return result;
142 }
143
144
145 /*
146  * Send a boot-mode command over the bulk-out pipe
147  *
148  * Command can be a raw command, which requires no preparation (and
149  * which might not even be following the command format). Checks that
150  * the right amount of data was transfered.
151  *
152  * To satisfy USB requirements (no onstack, vmalloc or in data segment
153  * buffers), we copy the command to i2400m->bm_cmd_buf and send it from
154  * there.
155  *
156  * @flags: pass thru from i2400m_bm_cmd()
157  * @return: cmd_size if ok, < 0 errno code on error.
158  */
159 ssize_t i2400mu_bus_bm_cmd_send(struct i2400m *i2400m,
160                                 const struct i2400m_bootrom_header *_cmd,
161                                 size_t cmd_size, int flags)
162 {
163         ssize_t result;
164         struct device *dev = i2400m_dev(i2400m);
165         struct i2400mu *i2400mu = container_of(i2400m, struct i2400mu, i2400m);
166         int opcode = _cmd == NULL ? -1 : i2400m_brh_get_opcode(_cmd);
167         struct i2400m_bootrom_header *cmd;
168         size_t cmd_size_a = ALIGN(cmd_size, 16);        /* USB restriction */
169
170         d_fnstart(8, dev, "(i2400m %p cmd %p size %zu)\n",
171                   i2400m, _cmd, cmd_size);
172         result = -E2BIG;
173         if (cmd_size > I2400M_BM_CMD_BUF_SIZE)
174                 goto error_too_big;
175         memcpy(i2400m->bm_cmd_buf, _cmd, cmd_size);
176         cmd = i2400m->bm_cmd_buf;
177         if (cmd_size_a > cmd_size)                      /* Zero pad space */
178                 memset(i2400m->bm_cmd_buf + cmd_size, 0, cmd_size_a - cmd_size);
179         if ((flags & I2400M_BM_CMD_RAW) == 0) {
180                 if (WARN_ON(i2400m_brh_get_response_required(cmd) == 0))
181                         dev_warn(dev, "SW BUG: response_required == 0\n");
182                 i2400m_bm_cmd_prepare(cmd);
183         }
184         result = i2400mu_tx_bulk_out(i2400mu, i2400m->bm_cmd_buf, cmd_size);
185         if (result < 0) {
186                 dev_err(dev, "boot-mode cmd %d: cannot send: %zd\n",
187                         opcode, result);
188                 goto error_cmd_send;
189         }
190         if (result != cmd_size) {               /* all was transferred? */
191                 dev_err(dev, "boot-mode cmd %d: incomplete transfer "
192                         "(%zu vs %zu submitted)\n",  opcode, result, cmd_size);
193                 result = -EIO;
194                 goto error_cmd_size;
195         }
196 error_cmd_size:
197 error_cmd_send:
198 error_too_big:
199         d_fnend(8, dev, "(i2400m %p cmd %p size %zu) = %zd\n",
200                 i2400m, _cmd, cmd_size, result);
201         return result;
202 }
203
204
205 static
206 void __i2400mu_bm_notif_cb(struct urb *urb)
207 {
208         complete(urb->context);
209 }
210
211
212 /*
213  * submit a read to the notification endpoint
214  *
215  * @i2400m: device descriptor
216  * @urb: urb to use
217  * @completion: completion varible to complete when done
218  *
219  * Data is always read to i2400m->bm_ack_buf
220  */
221 static
222 int i2400mu_notif_submit(struct i2400mu *i2400mu, struct urb *urb,
223                          struct completion *completion)
224 {
225         struct i2400m *i2400m = &i2400mu->i2400m;
226         struct usb_endpoint_descriptor *epd;
227         int pipe;
228
229         epd = usb_get_epd(i2400mu->usb_iface, I2400MU_EP_NOTIFICATION);
230         pipe = usb_rcvintpipe(i2400mu->usb_dev, epd->bEndpointAddress);
231         usb_fill_int_urb(urb, i2400mu->usb_dev, pipe,
232                          i2400m->bm_ack_buf, I2400M_BM_ACK_BUF_SIZE,
233                          __i2400mu_bm_notif_cb, completion,
234                          epd->bInterval);
235         return usb_submit_urb(urb, GFP_KERNEL);
236 }
237
238
239 /*
240  * Read an ack from  the notification endpoint
241  *
242  * @i2400m:
243  * @_ack: pointer to where to store the read data
244  * @ack_size: how many bytes we should read
245  *
246  * Returns: < 0 errno code on error; otherwise, amount of received bytes.
247  *
248  * Submits a notification read, appends the read data to the given ack
249  * buffer and then repeats (until @ack_size bytes have been
250  * received).
251  */
252 ssize_t i2400mu_bus_bm_wait_for_ack(struct i2400m *i2400m,
253                                     struct i2400m_bootrom_header *_ack,
254                                     size_t ack_size)
255 {
256         ssize_t result = -ENOMEM;
257         struct device *dev = i2400m_dev(i2400m);
258         struct i2400mu *i2400mu = container_of(i2400m, struct i2400mu, i2400m);
259         struct urb notif_urb;
260         void *ack = _ack;
261         size_t offset, len;
262         long val;
263         int do_autopm = 1;
264         DECLARE_COMPLETION_ONSTACK(notif_completion);
265
266         d_fnstart(8, dev, "(i2400m %p ack %p size %zu)\n",
267                   i2400m, ack, ack_size);
268         BUG_ON(_ack == i2400m->bm_ack_buf);
269         result = usb_autopm_get_interface(i2400mu->usb_iface);
270         if (result < 0) {
271                 dev_err(dev, "BM-ACK: can't get autopm: %d\n", (int) result);
272                 do_autopm = 0;
273         }
274         usb_init_urb(&notif_urb);       /* ready notifications */
275         usb_get_urb(&notif_urb);
276         offset = 0;
277         while (offset < ack_size) {
278                 init_completion(&notif_completion);
279                 result = i2400mu_notif_submit(i2400mu, &notif_urb,
280                                               &notif_completion);
281                 if (result < 0)
282                         goto error_notif_urb_submit;
283                 val = wait_for_completion_interruptible_timeout(
284                         &notif_completion, HZ);
285                 if (val == 0) {
286                         result = -ETIMEDOUT;
287                         usb_kill_urb(&notif_urb);       /* Timedout */
288                         goto error_notif_wait;
289                 }
290                 if (val == -ERESTARTSYS) {
291                         result = -EINTR;                /* Interrupted */
292                         usb_kill_urb(&notif_urb);
293                         goto error_notif_wait;
294                 }
295                 result = notif_urb.status;              /* How was the ack? */
296                 switch (result) {
297                 case 0:
298                         break;
299                 case -EINVAL:                   /* while removing driver */
300                 case -ENODEV:                   /* dev disconnect ... */
301                 case -ENOENT:                   /* just ignore it */
302                 case -ESHUTDOWN:                /* and exit */
303                 case -ECONNRESET:
304                         result = -ESHUTDOWN;
305                         goto error_dev_gone;
306                 default:                                /* any other? */
307                         usb_kill_urb(&notif_urb);       /* Timedout */
308                         if (edc_inc(&i2400mu->urb_edc,
309                                     EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME))
310                                 goto error_exceeded;
311                         dev_err(dev, "BM-ACK: URB error %d, "
312                                 "retrying\n", notif_urb.status);
313                         continue;       /* retry */
314                 }
315                 if (notif_urb.actual_length == 0) {
316                         d_printf(6, dev, "ZLP received, retrying\n");
317                         continue;
318                 }
319                 /* Got data, append it to the buffer */
320                 len = min(ack_size - offset, (size_t) notif_urb.actual_length);
321                 memcpy(ack + offset, i2400m->bm_ack_buf, len);
322                 offset += len;
323         }
324         result = offset;
325 error_notif_urb_submit:
326 error_notif_wait:
327 error_dev_gone:
328 out:
329         if (do_autopm)
330                 usb_autopm_put_interface(i2400mu->usb_iface);
331         d_fnend(8, dev, "(i2400m %p ack %p size %zu) = %zd\n",
332                 i2400m, ack, ack_size, result);
333         return result;
334
335 error_exceeded:
336         dev_err(dev, "bm: maximum errors in notification URB exceeded; "
337                 "resetting device\n");
338         usb_queue_reset_device(i2400mu->usb_iface);
339         goto out;
340 }