drivers/staging/vt6656/usbpipe.c

   1 /*
   2  * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
   3  * All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  *
  20  * File: usbpipe.c
  21  *
  22  * Purpose: Handle USB control endpoint
  23  *
  24  * Author: Warren Hsu
  25  *
  26  * Date: Mar. 29, 2005
  27  *
  28  * Functions:
  29  *      vnt_control_out - Write variable length bytes to MEM/BB/MAC/EEPROM
  30  *      vnt_control_in - Read variable length bytes from MEM/BB/MAC/EEPROM
  31  *      vnt_control_out_u8 - Write one byte to MEM/BB/MAC/EEPROM
  32  *      vnt_control_in_u8 - Read one byte from MEM/BB/MAC/EEPROM
  33  *
  34  * Revision History:
  35  *      04-05-2004 Jerry Chen:  Initial release
  36  *      11-24-2004 Warren Hsu: Add ControlvWriteByte,ControlvReadByte,ControlvMaskByte
  37  *
  38  */
  39
  40 #include "int.h"
  41 #include "rxtx.h"
  42 #include "dpc.h"
  43 #include "desc.h"
  44 #include "device.h"
  45 #include "usbpipe.h"
  46
  47 #define USB_CTL_WAIT    500 /* ms */
  48
  49 int vnt_control_out(struct vnt_private *priv, u8 request, u16 value,
  50                 u16 index, u16 length, u8 *buffer)
  51 {
  52         int status = 0;
  53
  54         if (test_bit(DEVICE_FLAGS_DISCONNECTED, &priv->flags))
  55                 return STATUS_FAILURE;
  56
  57         mutex_lock(&priv->usb_lock);
  58
  59         status = usb_control_msg(priv->usb,
  60                 usb_sndctrlpipe(priv->usb, 0), request, 0x40, value,
  61                         index, buffer, length, USB_CTL_WAIT);
  62
  63         mutex_unlock(&priv->usb_lock);
  64
  65         if (status < (int)length)
  66                 return STATUS_FAILURE;
  67
  68         return STATUS_SUCCESS;
  69 }
  70
  71 void vnt_control_out_u8(struct vnt_private *priv, u8 reg, u8 reg_off, u8 data)
  72 {
  73         vnt_control_out(priv, MESSAGE_TYPE_WRITE,
  74                                         reg_off, reg, sizeof(u8), &data);
  75 }
  76
  77 int vnt_control_in(struct vnt_private *priv, u8 request, u16 value,
  78                 u16 index, u16 length, u8 *buffer)
  79 {
  80         int status;
  81
  82         if (test_bit(DEVICE_FLAGS_DISCONNECTED, &priv->flags))
  83                 return STATUS_FAILURE;
  84
  85         mutex_lock(&priv->usb_lock);
  86
  87         status = usb_control_msg(priv->usb,
  88                 usb_rcvctrlpipe(priv->usb, 0), request, 0xc0, value,
  89                         index, buffer, length, USB_CTL_WAIT);
  90
  91         mutex_unlock(&priv->usb_lock);
  92
  93         if (status < (int)length)
  94                 return STATUS_FAILURE;
  95
  96         return STATUS_SUCCESS;
  97 }
  98
  99 void vnt_control_in_u8(struct vnt_private *priv, u8 reg, u8 reg_off, u8 *data)
 100 {
 101         vnt_control_in(priv, MESSAGE_TYPE_READ,
 102                         reg_off, reg, sizeof(u8), data);
 103 }
 104
 105 static void vnt_start_interrupt_urb_complete(struct urb *urb)
 106 {
 107         struct vnt_private *priv = urb->context;
 108         int status;
 109
 110         switch (urb->status) {
 111         case 0:
 112         case -ETIMEDOUT:
 113                 break;
 114         case -ECONNRESET:
 115         case -ENOENT:
 116         case -ESHUTDOWN:
 117                 priv->int_buf.in_use = false;
 118                 return;
 119         default:
 120                 break;
 121         }
 122
 123         status = urb->status;
 124
 125         if (status != STATUS_SUCCESS) {
 126                 priv->int_buf.in_use = false;
 127
 128                 dev_dbg(&priv->usb->dev, "%s status = %d\n", __func__, status);
 129         } else {
 130                 vnt_int_process_data(priv);
 131         }
 132
 133         status = usb_submit_urb(priv->interrupt_urb, GFP_ATOMIC);
 134         if (status) {
 135                 dev_dbg(&priv->usb->dev, "Submit int URB failed %d\n", status);
 136         } else {
 137                 priv->int_buf.in_use = true;
 138         }
 139 }
 140
 141 int vnt_start_interrupt_urb(struct vnt_private *priv)
 142 {
 143         int status = STATUS_FAILURE;
 144
 145         if (priv->int_buf.in_use == true)
 146                 return STATUS_FAILURE;
 147
 148         priv->int_buf.in_use = true;
 149
 150         usb_fill_int_urb(priv->interrupt_urb,
 151                          priv->usb,
 152                          usb_rcvintpipe(priv->usb, 1),
 153                          priv->int_buf.data_buf,
 154                          MAX_INTERRUPT_SIZE,
 155                          vnt_start_interrupt_urb_complete,
 156                          priv,
 157                          priv->int_interval);
 158
 159         status = usb_submit_urb(priv->interrupt_urb, GFP_ATOMIC);
 160         if (status) {
 161                 dev_dbg(&priv->usb->dev, "Submit int URB failed %d\n", status);
 162                 priv->int_buf.in_use = false;
 163         }
 164
 165         return status;
 166 }
 167
 168 static void vnt_submit_rx_urb_complete(struct urb *urb)
 169 {
 170         struct vnt_rcb *rcb = urb->context;
 171         struct vnt_private *priv = rcb->priv;
 172         unsigned long flags;
 173
 174         switch (urb->status) {
 175         case 0:
 176                 break;
 177         case -ECONNRESET:
 178         case -ENOENT:
 179         case -ESHUTDOWN:
 180                 return;
 181         case -ETIMEDOUT:
 182         default:
 183                 dev_dbg(&priv->usb->dev, "BULK In failed %d\n", urb->status);
 184                 break;
 185         }
 186
 187         if (urb->actual_length) {
 188                 spin_lock_irqsave(&priv->lock, flags);
 189
 190                 if (vnt_rx_data(priv, rcb, urb->actual_length)) {
 191                         rcb->skb = dev_alloc_skb(priv->rx_buf_sz);
 192                         if (!rcb->skb) {
 193                                 dev_dbg(&priv->usb->dev,
 194                                         "Failed to re-alloc rx skb\n");
 195
 196                                 rcb->in_use = false;
 197                                 spin_unlock_irqrestore(&priv->lock, flags);
 198                                 return;
 199                         }
 200                 } else {
 201                         skb_push(rcb->skb, skb_headroom(rcb->skb));
 202                         skb_trim(rcb->skb, 0);
 203                 }
 204
 205                 urb->transfer_buffer = skb_put(rcb->skb,
 206                                                 skb_tailroom(rcb->skb));
 207
 208                 spin_unlock_irqrestore(&priv->lock, flags);
 209         }
 210
 211         if (usb_submit_urb(urb, GFP_ATOMIC)) {
 212                 dev_dbg(&priv->usb->dev, "Failed to re submit rx skb\n");
 213
 214                 rcb->in_use = false;
 215         }
 216 }
 217
 218 int vnt_submit_rx_urb(struct vnt_private *priv, struct vnt_rcb *rcb)
 219 {
 220         int status = 0;
 221         struct urb *urb;
 222
 223         urb = rcb->urb;
 224         if (rcb->skb == NULL) {
 225                 dev_dbg(&priv->usb->dev, "rcb->skb is null\n");
 226                 return status;
 227         }
 228
 229         usb_fill_bulk_urb(urb,
 230                           priv->usb,
 231                           usb_rcvbulkpipe(priv->usb, 2),
 232                           skb_put(rcb->skb, skb_tailroom(rcb->skb)),
 233                           MAX_TOTAL_SIZE_WITH_ALL_HEADERS,
 234                           vnt_submit_rx_urb_complete,
 235                           rcb);
 236
 237         status = usb_submit_urb(urb, GFP_ATOMIC);
 238         if (status != 0) {
 239                 dev_dbg(&priv->usb->dev, "Submit Rx URB failed %d\n", status);
 240                 return STATUS_FAILURE;
 241         }
 242
 243         rcb->in_use = true;
 244
 245         return status;
 246 }
 247
 248 static void vnt_tx_context_complete(struct urb *urb)
 249 {
 250         struct vnt_usb_send_context *context = urb->context;
 251         struct vnt_private *priv = context->priv;
 252
 253         switch (urb->status) {
 254         case 0:
 255                 dev_dbg(&priv->usb->dev, "Write %d bytes\n", context->buf_len);
 256                 break;
 257         case -ECONNRESET:
 258         case -ENOENT:
 259         case -ESHUTDOWN:
 260                 context->in_use = false;
 261                 return;
 262         case -ETIMEDOUT:
 263         default:
 264                 dev_dbg(&priv->usb->dev, "BULK Out failed %d\n", urb->status);
 265                 break;
 266         }
 267
 268         if (context->type == CONTEXT_DATA_PACKET)
 269                 ieee80211_wake_queues(priv->hw);
 270
 271         if (urb->status || context->type == CONTEXT_BEACON_PACKET) {
 272                 if (context->skb)
 273                         ieee80211_free_txskb(priv->hw, context->skb);
 274
 275                 context->in_use = false;
 276         }
 277 }
 278
 279 int vnt_tx_context(struct vnt_private *priv,
 280                    struct vnt_usb_send_context *context)
 281 {
 282         int status;
 283         struct urb *urb;
 284
 285         if (test_bit(DEVICE_FLAGS_DISCONNECTED, &priv->flags)) {
 286                 context->in_use = false;
 287                 return STATUS_RESOURCES;
 288         }
 289
 290         urb = context->urb;
 291
 292         usb_fill_bulk_urb(urb,
 293                           priv->usb,
 294                           usb_sndbulkpipe(priv->usb, 3),
 295                           context->data,
 296                           context->buf_len,
 297                           vnt_tx_context_complete,
 298                           context);
 299
 300         status = usb_submit_urb(urb, GFP_ATOMIC);
 301         if (status != 0) {
 302                 dev_dbg(&priv->usb->dev, "Submit Tx URB failed %d\n", status);
 303
 304                 context->in_use = false;
 305                 return STATUS_FAILURE;
 306         }
 307
 308         return STATUS_PENDING;
 309 }