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 }