kernel/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 int vnt_start_interrupt_urb(struct vnt_private *priv)
 141 {
 142         int status = STATUS_FAILURE;
 143
 144         if (priv->int_buf.in_use)
 145                 return STATUS_FAILURE;
 146
 147         priv->int_buf.in_use = true;
 148
 149         usb_fill_int_urb(priv->interrupt_urb,
 150                          priv->usb,
 151                          usb_rcvintpipe(priv->usb, 1),
 152                          priv->int_buf.data_buf,
 153                          MAX_INTERRUPT_SIZE,
 154                          vnt_start_interrupt_urb_complete,
 155                          priv,
 156                          priv->int_interval);
 157
 158         status = usb_submit_urb(priv->interrupt_urb, GFP_ATOMIC);
 159         if (status) {
 160                 dev_dbg(&priv->usb->dev, "Submit int URB failed %d\n", status);
 161                 priv->int_buf.in_use = false;
 162         }
 163
 164         return status;
 165 }
 166
 167 static void vnt_submit_rx_urb_complete(struct urb *urb)
 168 {
 169         struct vnt_rcb *rcb = urb->context;
 170         struct vnt_private *priv = rcb->priv;
 171
 172         switch (urb->status) {
 173         case 0:
 174                 break;
 175         case -ECONNRESET:
 176         case -ENOENT:
 177         case -ESHUTDOWN:
 178                 return;
 179         case -ETIMEDOUT:
 180         default:
 181                 dev_dbg(&priv->usb->dev, "BULK In failed %d\n", urb->status);
 182                 break;
 183         }
 184
 185         if (urb->actual_length) {
 186                 if (vnt_rx_data(priv, rcb, urb->actual_length)) {
 187                         rcb->skb = dev_alloc_skb(priv->rx_buf_sz);
 188                         if (!rcb->skb) {
 189                                 dev_dbg(&priv->usb->dev,
 190                                         "Failed to re-alloc rx skb\n");
 191
 192                                 rcb->in_use = false;
 193                                 return;
 194                         }
 195                 } else {
 196                         skb_push(rcb->skb, skb_headroom(rcb->skb));
 197                         skb_trim(rcb->skb, 0);
 198                 }
 199
 200                 urb->transfer_buffer = skb_put(rcb->skb,
 201                                                 skb_tailroom(rcb->skb));
 202         }
 203
 204         if (usb_submit_urb(urb, GFP_ATOMIC)) {
 205                 dev_dbg(&priv->usb->dev, "Failed to re submit rx skb\n");
 206
 207                 rcb->in_use = false;
 208         }
 209 }
 210
 211 int vnt_submit_rx_urb(struct vnt_private *priv, struct vnt_rcb *rcb)
 212 {
 213         int status = 0;
 214         struct urb *urb;
 215
 216         urb = rcb->urb;
 217         if (rcb->skb == NULL) {
 218                 dev_dbg(&priv->usb->dev, "rcb->skb is null\n");
 219                 return status;
 220         }
 221
 222         usb_fill_bulk_urb(urb,
 223                           priv->usb,
 224                           usb_rcvbulkpipe(priv->usb, 2),
 225                           skb_put(rcb->skb, skb_tailroom(rcb->skb)),
 226                           MAX_TOTAL_SIZE_WITH_ALL_HEADERS,
 227                           vnt_submit_rx_urb_complete,
 228                           rcb);
 229
 230         status = usb_submit_urb(urb, GFP_ATOMIC);
 231         if (status != 0) {
 232                 dev_dbg(&priv->usb->dev, "Submit Rx URB failed %d\n", status);
 233                 return STATUS_FAILURE;
 234         }
 235
 236         rcb->in_use = true;
 237
 238         return status;
 239 }
 240
 241 static void vnt_tx_context_complete(struct urb *urb)
 242 {
 243         struct vnt_usb_send_context *context = urb->context;
 244         struct vnt_private *priv = context->priv;
 245
 246         switch (urb->status) {
 247         case 0:
 248                 dev_dbg(&priv->usb->dev, "Write %d bytes\n", context->buf_len);
 249                 break;
 250         case -ECONNRESET:
 251         case -ENOENT:
 252         case -ESHUTDOWN:
 253                 context->in_use = false;
 254                 return;
 255         case -ETIMEDOUT:
 256         default:
 257                 dev_dbg(&priv->usb->dev, "BULK Out failed %d\n", urb->status);
 258                 break;
 259         }
 260
 261         if (context->type == CONTEXT_DATA_PACKET)
 262                 ieee80211_wake_queues(priv->hw);
 263
 264         if (urb->status || context->type == CONTEXT_BEACON_PACKET) {
 265                 if (context->skb)
 266                         ieee80211_free_txskb(priv->hw, context->skb);
 267
 268                 context->in_use = false;
 269         }
 270 }
 271
 272 int vnt_tx_context(struct vnt_private *priv,
 273                    struct vnt_usb_send_context *context)
 274 {
 275         int status;
 276         struct urb *urb;
 277
 278         if (test_bit(DEVICE_FLAGS_DISCONNECTED, &priv->flags)) {
 279                 context->in_use = false;
 280                 return STATUS_RESOURCES;
 281         }
 282
 283         urb = context->urb;
 284
 285         usb_fill_bulk_urb(urb,
 286                           priv->usb,
 287                           usb_sndbulkpipe(priv->usb, 3),
 288                           context->data,
 289                           context->buf_len,
 290                           vnt_tx_context_complete,
 291                           context);
 292
 293         status = usb_submit_urb(urb, GFP_ATOMIC);
 294         if (status != 0) {
 295                 dev_dbg(&priv->usb->dev, "Submit Tx URB failed %d\n", status);
 296
 297                 context->in_use = false;
 298                 return STATUS_FAILURE;
 299         }
 300
 301         return STATUS_PENDING;
 302 }